Na}{

Server IP:199.192.16.65

Your IP:216.73.217.137

Web Server:Apache

System:Linux server1.csender.net 4.18.0-553.69.1.el8_10.x86_64 #1 SMP Mon Aug 11 07:22:08 EDT 2025 x86_64 x86_64 x86_64 GNU/Linux

User:csender

PHP Version:8.2.30

Disable Function: NONE

MySQL: OFF

cURL: ON

WGET: ON

Perl: ON

Python: OFF

Sudo: ON

Pkexec: ON

Command Bosku:

Path: ~//usr/include/mysql/server/private/

File Content: `sql_explain.h`

/*
   Copyright (c) 2013 Monty Program Ab

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */

/*

== EXPLAIN/ANALYZE architecture ==

=== [SHOW] EXPLAIN data ===
Query optimization produces two data structures:
1. execution data structures themselves (eg. JOINs, JOIN_TAB, etc, etc)
2. Explain data structures.

#2 are self contained set of data structures that has sufficient info to
produce output of SHOW EXPLAIN, EXPLAIN [FORMAT=JSON], or 
ANALYZE [FORMAT=JSON], without accessing the execution data structures.

(the only exception is that Explain data structures keep Item* pointers,
and we require that one might call item->print(QT_EXPLAIN) when printing
FORMAT=JSON output)

=== ANALYZE data ===
EXPLAIN data structures have embedded ANALYZE data structures. These are 
objects that are used to track how the parts of query plan were executed:
how many times each part of query plan was invoked, how many rows were
read/returned, etc.

Each execution data structure keeps a direct pointer to its ANALYZE data
structure. It is needed so that execution code can quickly increment the
counters.

(note that this increases the set of data that is frequently accessed 
during the execution. What is the impact of this?)

Since ANALYZE/EXPLAIN data structures are separated from execution data
structures, it is easy to have them survive until the end of the query,
where we can return ANALYZE [FORMAT=JSON] output to the user, or print 
it into the slow query log.

*/

#ifndef SQL_EXPLAIN_INCLUDED
#define SQL_EXPLAIN_INCLUDED

class String_list: public List<char>
{
public:
  const char *append_str(MEM_ROOT *mem_root, const char *str);
};

class Json_writer;

/**************************************************************************************
 
  Data structures for producing EXPLAIN outputs.

  These structures
  - Can be produced inexpensively from query plan.
  - Store sufficient information to produce tabular EXPLAIN output (the goal is 
    to be able to produce JSON also)

*************************************************************************************/


const uint FAKE_SELECT_LEX_ID= UINT_MAX;

class Explain_query;

/* 
  A node can be either a SELECT, or a UNION.
*/
class Explain_node : public Sql_alloc
{
public:
  Explain_node(MEM_ROOT *root) :
    cache_tracker(NULL),
    subq_materialization(NULL),
    connection_type(EXPLAIN_NODE_OTHER),
    children(root)
  {}
  /* A type specifying what kind of node this is */
  enum explain_node_type 
  {
    EXPLAIN_UNION, 
    EXPLAIN_SELECT,
    EXPLAIN_BASIC_JOIN,
    EXPLAIN_UPDATE,
    EXPLAIN_DELETE, 
    EXPLAIN_INSERT
  };
  
  /* How this node is connected */
  enum explain_connection_type {
    EXPLAIN_NODE_OTHER,
    EXPLAIN_NODE_DERIVED, /* Materialized derived table */
    EXPLAIN_NODE_NON_MERGED_SJ /* aka JTBM semi-join */
  };

  virtual enum explain_node_type get_type()= 0;
  virtual uint get_select_id()= 0;

  /**
    expression cache statistics
  */
  Expression_cache_tracker* cache_tracker;

  /**
    If not NULL, this node is a SELECT (or UNION) in a materialized
    IN-subquery.
  */
  Explain_subq_materialization* subq_materialization;

  /*
    How this node is connected to its parent.
    (NOTE: EXPLAIN_NODE_NON_MERGED_SJ is set very late currently)
  */
  enum explain_connection_type connection_type;

protected:
  /* 
    A node may have children nodes. When a node's explain structure is 
    created, children nodes may not yet have QPFs. This is why we store ids.
  */
  Dynamic_array<int> children;
public:
  void add_child(int select_no)
  {
    children.append(select_no);
  }

  virtual int print_explain(Explain_query *query, select_result_sink *output, 
                            uint8 explain_flags, bool is_analyze)=0;
  virtual void print_explain_json(Explain_query *query, Json_writer *writer, 
                                  bool is_analyze)= 0;

  int print_explain_for_children(Explain_query *query, select_result_sink *output, 
                                 uint8 explain_flags, bool is_analyze);
  void print_explain_json_for_children(Explain_query *query,
                                       Json_writer *writer, bool is_analyze);
  bool print_explain_json_cache(Json_writer *writer, bool is_analyze);
  bool print_explain_json_subq_materialization(Json_writer *writer,
                                               bool is_analyze);
  virtual ~Explain_node() = default;
};


class Explain_table_access;


/* 
  A basic join. This is only used for SJ-Materialization nests.

  Basic join doesn't have ORDER/GROUP/DISTINCT operations. It also cannot be
  degenerate.

  It has its own select_id.
*/
class Explain_basic_join : public Explain_node
{
public:
  enum explain_node_type get_type() override { return EXPLAIN_BASIC_JOIN; }
  
  Explain_basic_join(MEM_ROOT *root) : Explain_node(root), join_tabs(NULL) {}
  ~Explain_basic_join();

  bool add_table(Explain_table_access *tab, Explain_query *query);

  uint get_select_id() override { return select_id; }

  uint select_id;

  int print_explain(Explain_query *query, select_result_sink *output,
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer, 
                          bool is_analyze) override;

  void print_explain_json_interns(Explain_query *query, Json_writer *writer,
                                  bool is_analyze);

  /* A flat array of Explain structs for tables. */
  Explain_table_access** join_tabs;
  uint n_join_tabs;
};


class Explain_aggr_node;
/*
  EXPLAIN structure for a SELECT.
  
  A select can be:
  1. A degenerate case. In this case, message!=NULL, and it contains a 
     description of what kind of degenerate case it is (e.g. "Impossible 
     WHERE").
  2. a non-degenrate join. In this case, join_tabs describes the join.

  In the non-degenerate case, a SELECT may have a GROUP BY/ORDER BY operation.

  In both cases, the select may have children nodes. class Explain_node
  provides a way get node's children.
*/

class Explain_select : public Explain_basic_join
{
public:
  enum explain_node_type get_type() override { return EXPLAIN_SELECT; }

  Explain_select(MEM_ROOT *root, bool is_analyze) : 
  Explain_basic_join(root),
#ifndef DBUG_OFF
    select_lex(NULL),
#endif
    linkage(UNSPECIFIED_TYPE),
    is_lateral(false),
    message(NULL),
    having(NULL), having_value(Item::COND_UNDEF),
    using_temporary(false), using_filesort(false),
    time_tracker(is_analyze),
    aggr_tree(NULL)
  {}

  void add_linkage(Json_writer *writer);

public:
#ifndef DBUG_OFF
  SELECT_LEX *select_lex;
#endif
  const char *select_type;
  enum sub_select_type linkage;
  bool is_lateral;

  /*
    If message != NULL, this is a degenerate join plan, and all subsequent
    members have no info 
  */
  const char *message;

  /* Expensive constant condition */
  Item *exec_const_cond;
  Item *outer_ref_cond;
  Item *pseudo_bits_cond;

  /* HAVING condition */
  Item *having;
  Item::cond_result having_value;

  /* Global join attributes. In tabular form, they are printed on the first row */
  bool using_temporary;
  bool using_filesort;

  /* ANALYZE members */
  Time_and_counter_tracker time_tracker;
  
  /* 
    Part of query plan describing sorting, temp.table usage, and duplicate 
    removal
  */
  Explain_aggr_node* aggr_tree;

  int print_explain(Explain_query *query, select_result_sink *output, 
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer, 
                          bool is_analyze) override;
  
  Table_access_tracker *get_using_temporary_read_tracker()
  {
    return &using_temporary_read_tracker;
  }
private:
  Table_access_tracker using_temporary_read_tracker;
};

/////////////////////////////////////////////////////////////////////////////
// EXPLAIN structures for ORDER/GROUP operations.
/////////////////////////////////////////////////////////////////////////////
typedef enum 
{
  AGGR_OP_TEMP_TABLE,
  AGGR_OP_FILESORT,
  //AGGR_OP_READ_SORTED_FILE, // need this?
  AGGR_OP_REMOVE_DUPLICATES,
  AGGR_OP_WINDOW_FUNCS
  //AGGR_OP_JOIN // Need this?
} enum_explain_aggr_node_type;


class Explain_aggr_node : public Sql_alloc
{
public:
  virtual enum_explain_aggr_node_type get_type()= 0;
  virtual ~Explain_aggr_node() = default;
  Explain_aggr_node *child;
};

class Explain_aggr_filesort : public Explain_aggr_node
{
  List<Item> sort_items;
  List<ORDER::enum_order> sort_directions;
public:
  enum_explain_aggr_node_type get_type() override { return AGGR_OP_FILESORT; }
  Filesort_tracker tracker;

  Explain_aggr_filesort(MEM_ROOT *mem_root, bool is_analyze, 
                        Filesort *filesort);

  void print_json_members(Json_writer *writer, bool is_analyze);
};

class Explain_aggr_tmp_table : public Explain_aggr_node
{
public:
  enum_explain_aggr_node_type get_type() override { return AGGR_OP_TEMP_TABLE; }
};

class Explain_aggr_remove_dups : public Explain_aggr_node
{
public:
  enum_explain_aggr_node_type get_type() override { return AGGR_OP_REMOVE_DUPLICATES; }
};

class Explain_aggr_window_funcs : public Explain_aggr_node
{
  List<Explain_aggr_filesort> sorts;
public:
  enum_explain_aggr_node_type get_type() override { return AGGR_OP_WINDOW_FUNCS; }

  void print_json_members(Json_writer *writer, bool is_analyze);
  friend class Window_funcs_computation;
};

/////////////////////////////////////////////////////////////////////////////

extern const char *unit_operation_text[4];
extern const char *pushed_derived_text;
extern const char *pushed_select_text;

/*
  Explain structure for a UNION.

  A UNION may or may not have "Using filesort".
*/

class Explain_union : public Explain_node
{
public:
  Explain_union(MEM_ROOT *root, bool is_analyze) : 
    Explain_node(root), union_members(PSI_INSTRUMENT_MEM),
    is_recursive_cte(false),
    fake_select_lex_explain(root, is_analyze)
  {}

  enum explain_node_type get_type() override { return EXPLAIN_UNION; }
  unit_common_op operation;

  uint get_select_id() override
  {
    DBUG_ASSERT(union_members.elements() > 0);
    return union_members.at(0);
  }
  /*
    Members of the UNION.  Note: these are different from UNION's "children".
    Example:

      (select * from t1) union 
      (select * from t2) order by (select col1 from t3 ...)

    here 
      - select-from-t1 and select-from-t2 are "union members",
      - select-from-t3 is the only "child".
  */
  Dynamic_array<int> union_members;

  void add_select(int select_no)
  {
    union_members.append(select_no);
  }
  int print_explain(Explain_query *query, select_result_sink *output, 
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer, 
                          bool is_analyze) override;

  const char *fake_select_type;
  bool using_filesort;
  bool using_tmp;
  bool is_recursive_cte;
  
  /*
    Explain data structure for "fake_select_lex" (i.e. for the degenerate
    SELECT that reads UNION result).
    It doesn't have a query plan, but we still need execution tracker, etc.
  */
  Explain_select fake_select_lex_explain;

  Table_access_tracker *get_fake_select_lex_tracker()
  {
    return &fake_select_lex_tracker;
  }
  Table_access_tracker *get_tmptable_read_tracker()
  {
    return &tmptable_read_tracker;
  }
private:
  uint make_union_table_name(char *buf);
  
  Table_access_tracker fake_select_lex_tracker;
  /* This one is for reading after ORDER BY */
  Table_access_tracker tmptable_read_tracker; 
};


class Explain_update;
class Explain_delete;
class Explain_insert;


/*
  Explain structure for a query (i.e. a statement).

  This should be able to survive when the query plan was deleted. Currently, 
  we do not intend for it survive until after query's MEM_ROOT is freed. It
  does surivive freeing of query's items.
   
  For reference, the process of post-query cleanup is as follows:

    >dispatch_command
    | >mysql_parse
    | |  ...
    | | lex_end()
    | |  ...
    | | >THD::cleanup_after_query
    | | | ...
    | | | free_items()
    | | | ...
    | | <THD::cleanup_after_query
    | |
    | <mysql_parse
    |
    | log_slow_statement()
    | 
    | free_root()
    | 
    >dispatch_command
  
  That is, the order of actions is:
    - free query's Items
    - write to slow query log 
    - free query's MEM_ROOT
    
*/

class Explain_query : public Sql_alloc
{
public:
  Explain_query(THD *thd, MEM_ROOT *root);
  ~Explain_query();

  /* Add a new node */
  void add_node(Explain_node *node);
  void add_insert_plan(Explain_insert *insert_plan_arg);
  void add_upd_del_plan(Explain_update *upd_del_plan_arg);

  /* This will return a select, or a union */
  Explain_node *get_node(uint select_id);

  /* This will return a select (even if there is a union with this id) */
  Explain_select *get_select(uint select_id);
  
  Explain_union *get_union(uint select_id);
 
  /* Produce a tabular EXPLAIN output */
  int print_explain(select_result_sink *output, uint8 explain_flags, 
                    bool is_analyze);
  
  /* Send tabular EXPLAIN to the client */
  int send_explain(THD *thd, bool extended);
  
  /* Return tabular EXPLAIN output as a text string */
  bool print_explain_str(THD *thd, String *out_str, bool is_analyze);

  void print_explain_json(select_result_sink *output, bool is_analyze);

  /* If true, at least part of EXPLAIN can be printed */
  bool have_query_plan() { return insert_plan || upd_del_plan|| get_node(1) != NULL; }

  void query_plan_ready();

  MEM_ROOT *mem_root;

  Explain_update *get_upd_del_plan() { return upd_del_plan; }
private:
  /* Explain_delete inherits from Explain_update */
  Explain_update *upd_del_plan;

  /* Query "plan" for INSERTs */
  Explain_insert *insert_plan;

  Dynamic_array<Explain_union*> unions;
  Dynamic_array<Explain_select*> selects;
  
  THD *thd; // for APC start/stop
  bool apc_enabled;
  /* 
    Debugging aid: count how many times add_node() was called. Ideally, it
    should be one, we currently allow O(1) query plan saves for each
    select or union.  The goal is not to have O(#rows_in_some_table), which 
    is unacceptable.
  */
  longlong operations;
};


/* 
  Some of the tags have matching text. See extra_tag_text for text names, and 
  Explain_table_access::append_tag_name() for code to convert from tag form to text
  form.
*/
enum explain_extra_tag
{
  ET_none= 0, /* not-a-tag */
  ET_USING_INDEX_CONDITION,
  ET_USING_INDEX_CONDITION_BKA,
  ET_USING, /* For quick selects of various kinds */
  ET_RANGE_CHECKED_FOR_EACH_RECORD,
  ET_USING_WHERE_WITH_PUSHED_CONDITION,
  ET_USING_WHERE,
  ET_NOT_EXISTS,

  ET_USING_INDEX,
  ET_FULL_SCAN_ON_NULL_KEY,
  ET_SKIP_OPEN_TABLE,
  ET_OPEN_FRM_ONLY,
  ET_OPEN_FULL_TABLE,

  ET_SCANNED_0_DATABASES,
  ET_SCANNED_1_DATABASE,
  ET_SCANNED_ALL_DATABASES,

  ET_USING_INDEX_FOR_GROUP_BY,

  ET_USING_MRR, // does not print "Using mrr". 

  ET_DISTINCT,
  ET_LOOSESCAN,
  ET_START_TEMPORARY,
  ET_END_TEMPORARY,
  ET_FIRST_MATCH,
  
  ET_USING_JOIN_BUFFER,

  ET_CONST_ROW_NOT_FOUND,
  ET_UNIQUE_ROW_NOT_FOUND,
  ET_IMPOSSIBLE_ON_CONDITION,
  ET_TABLE_FUNCTION,

  ET_total
};


/*
  Explain data structure describing join buffering use.
*/

class EXPLAIN_BKA_TYPE
{
public:
  EXPLAIN_BKA_TYPE() : join_alg(NULL) {}

  size_t join_buffer_size;

  bool incremental;

  /* 
    NULL if no join buferring used.
    Other values: BNL, BNLH, BKA, BKAH.
  */
  const char *join_alg;

  /* Information about MRR usage.  */
  StringBuffer<64> mrr_type;
  
  bool is_using_jbuf() { return (join_alg != NULL); }
};


/*
  Data about how an index is used by some access method
*/
class Explain_index_use : public Sql_alloc
{
  char *key_name;
  uint key_len;
  char *filter_name;
  uint filter_len;
public:
  String_list key_parts_list;
  
  Explain_index_use()
  {
    clear();
  }

  void clear()
  {
    key_name= NULL;
    key_len= (uint)-1;
    filter_name= NULL;
    filter_len= (uint)-1;
  }
  bool set(MEM_ROOT *root, KEY *key_name, uint key_len_arg);
  bool set_pseudo_key(MEM_ROOT *root, const char *key_name);

  inline const char *get_key_name() const { return key_name; }
  inline uint get_key_len() const { return key_len; }
  //inline const char *get_filter_name() const { return filter_name; }
};


/*
  Query Plan data structure for Rowid filter.
*/
class Explain_rowid_filter : public Sql_alloc
{
public:
  /* Quick select used to collect the rowids into filter */
  Explain_quick_select *quick;

  /* How many rows the above quick select is expected to return */
  ha_rows rows;

  /* Expected selectivity for the filter */
  double selectivity;

  /* Tracker with the information about how rowid filter is executed */
  Rowid_filter_tracker *tracker;

  void print_explain_json(Explain_query *query, Json_writer *writer,
                          bool is_analyze);

  /*
    TODO:
      Here should be ANALYZE members:
      - r_rows for the quick select
      - An object that tracked the table access time
      - real selectivity of the filter.
  */
};


/*
  QPF for quick range selects, as well as index_merge select
*/
class Explain_quick_select : public Sql_alloc
{
public:
  Explain_quick_select(int quick_type_arg) : quick_type(quick_type_arg) 
  {}

  const int quick_type;

  bool is_basic() 
  {
    return (quick_type == QUICK_SELECT_I::QS_TYPE_RANGE || 
            quick_type == QUICK_SELECT_I::QS_TYPE_RANGE_DESC ||
            quick_type == QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX);
  }
  
  /* This is used when quick_type == QUICK_SELECT_I::QS_TYPE_RANGE */
  Explain_index_use range;
  
  /* Used in all other cases */
  List<Explain_quick_select> children;
  
  void print_extra(String *str);
  void print_key(String *str);
  void print_key_len(String *str);

  void print_json(Json_writer *writer);

  void print_extra_recursive(String *str);
private:
  const char *get_name_by_type();
};


/*
  Data structure for "range checked for each record". 
  It's a set of keys, tabular explain prints hex bitmap, json prints key names.
*/

typedef const char* NAME;

class Explain_range_checked_fer : public Sql_alloc
{
public:
  String_list key_set;
  key_map keys_map;
private:
  ha_rows full_scan, index_merge;
  ha_rows *keys_stat;
  NAME *keys_stat_names;
  uint keys;

public:
  Explain_range_checked_fer()
    :Sql_alloc(), full_scan(0), index_merge(0),
    keys_stat(0), keys_stat_names(0), keys(0)
  {}

  int append_possible_keys_stat(MEM_ROOT *alloc,
                                TABLE *table, key_map possible_keys);
  void collect_data(QUICK_SELECT_I *quick);
  void print_json(Json_writer *writer, bool is_analyze);
};


/*
  EXPLAIN data structure for a single JOIN_TAB.
*/

class Explain_table_access : public Sql_alloc
{
public:
  Explain_table_access(MEM_ROOT *root, bool timed) :
    derived_select_number(0),
    non_merged_sjm_number(0),
    extra_tags(root),
    range_checked_fer(NULL),
    full_scan_on_null_key(false),
    start_dups_weedout(false),
    end_dups_weedout(false),
    where_cond(NULL),
    cache_cond(NULL),
    pushed_index_cond(NULL),
    sjm_nest(NULL),
    pre_join_sort(NULL),
    handler_for_stats(NULL),
    jbuf_unpack_tracker(timed),
    rowid_filter(NULL)
  {}
  ~Explain_table_access() { delete sjm_nest; }

  void push_extra(enum explain_extra_tag extra_tag);

  /* Internals */

  /* id and 'select_type' are cared-of by the parent Explain_select */
  StringBuffer<32> table_name;
  StringBuffer<32> used_partitions;
  String_list used_partitions_list;
  // valid with ET_USING_MRR
  StringBuffer<32> mrr_type;
  StringBuffer<32> firstmatch_table_name;

  /* 
    Non-zero number means this is a derived table. The number can be used to
    find the query plan for the derived table
  */
  int derived_select_number;
  /* TODO: join with the previous member. */
  int non_merged_sjm_number;

  enum join_type type;

  bool used_partitions_set;
  
  /* Empty means "NULL" will be printed */
  String_list possible_keys;

  bool rows_set; /* not set means 'NULL' should be printed */
  bool filtered_set; /* not set means 'NULL' should be printed */
  // Valid if ET_USING_INDEX_FOR_GROUP_BY is present
  bool loose_scan_is_scanning;
  
  /*
    Index use: key name and length.
    Note: that when one is accessing I_S tables, those may show use of 
    non-existant indexes.

    key.key_name == NULL means 'NULL' will be shown in tabular output.
    key.key_len == (uint)-1 means 'NULL' will be shown in tabular output.
  */
  Explain_index_use key;
  
  /*
    when type==JT_HASH_NEXT, 'key' stores the hash join pseudo-key.
    hash_next_key stores the table's key.
  */
  Explain_index_use hash_next_key;
  
  String_list ref_list;

  ha_rows rows;
  double filtered;

  /* 
    Contents of the 'Extra' column. Some are converted into strings, some have
    parameters, values for which are stored below.
  */
  Dynamic_array<enum explain_extra_tag> extra_tags;

  // Valid if ET_USING tag is present
  Explain_quick_select *quick_info;
  
  /* Non-NULL value means this tab uses "range checked for each record" */
  Explain_range_checked_fer *range_checked_fer;
 
  bool full_scan_on_null_key;

  // valid with ET_USING_JOIN_BUFFER
  EXPLAIN_BKA_TYPE bka_type;

  bool start_dups_weedout;
  bool end_dups_weedout;
  
  /*
    Note: lifespan of WHERE condition is less than lifespan of this object.
    The below two are valid if tags include "ET_USING_WHERE".
    (TODO: indexsubquery may put ET_USING_WHERE without setting where_cond?)
  */
  Item *where_cond;
  Item *cache_cond;
  
  /*
    This is either pushed index condition, or BKA's index condition. 
    (the latter refers to columns of other tables and so can only be checked by
     BKA code). Examine extra_tags to tell which one it is.
  */
  Item *pushed_index_cond;

  Explain_basic_join *sjm_nest;
  
  /*
    This describes a possible filesort() call that is done before doing the
    join operation.
  */
  Explain_aggr_filesort *pre_join_sort;

  /* ANALYZE members */

  /* Tracker for reading the table */
  Table_access_tracker tracker;
  Exec_time_tracker op_tracker;
  Gap_time_tracker extra_time_tracker;

  /*
    Handler object to get the handler_stats from.

    Notes:
    This pointer is only valid until notify_tables_are_closed() is called.
    After that, the tables may be freed or reused, together with their
    handler_stats objects.
    notify_tables_are_closed() disables printing of FORMAT=JSON output.
    r_engine_stats is only printed in FORMAT=JSON output, so we're fine.

    We do not store pointers to temporary (aka "work") tables here.
    Temporary tables may be freed (e.g. by JOIN::cleanup()) or re-created
    during query execution (when HEAP table is converted into Aria).
  */
  handler *handler_for_stats;

  /* When using join buffer: Track the reads from join buffer */
  Table_access_tracker jbuf_tracker;

  /* When using join buffer: time spent unpacking rows from the join buffer */
  Time_and_counter_tracker jbuf_unpack_tracker;

  /*
    When using join buffer: time spent after unpacking rows from the join
    buffer. This will capture the time spent checking the Join Condition:
    the condition that depends on this table and preceding tables.
  */
  Gap_time_tracker jbuf_extra_time_tracker;

  /* When using join buffer: Track the number of incoming record combinations */
  Counter_tracker jbuf_loops_tracker;

  Explain_rowid_filter *rowid_filter;

  int print_explain(select_result_sink *output, uint8 explain_flags, 
                    bool is_analyze,
                    uint select_id, const char *select_type,
                    bool using_temporary, bool using_filesort);
  void print_explain_json(Explain_query *query, Json_writer *writer,
                          bool is_analyze);

private:
  void append_tag_name(String *str, enum explain_extra_tag tag);
  void fill_key_str(String *key_str, bool is_json) const;
  void fill_key_len_str(String *key_len_str, bool is_json) const;
  double get_r_filtered();
  void tag_to_json(Json_writer *writer, enum explain_extra_tag tag);
};


/*
  EXPLAIN structure for single-table UPDATE. 
  
  This is similar to Explain_table_access, except that it is more restrictive.
  Also, it can have UPDATE operation options, but currently there aren't any.

  Explain_delete inherits from this.
*/

class Explain_update : public Explain_node
{
public:

  Explain_update(MEM_ROOT *root, bool is_analyze) : 
    Explain_node(root),
    filesort_tracker(NULL),
    command_tracker(is_analyze),
    handler_for_stats(NULL)
  {}

  enum explain_node_type get_type() override { return EXPLAIN_UPDATE; }
  uint get_select_id() override { return 1; /* always root */ }

  const char *select_type;

  StringBuffer<32> used_partitions;
  String_list used_partitions_list;
  bool used_partitions_set;

  bool impossible_where;
  bool no_partitions;
  StringBuffer<64> table_name;

  enum join_type jtype;
  String_list possible_keys;

  /* Used key when doing a full index scan (possibly with limit) */
  Explain_index_use key;

  /* 
    MRR that's used with quick select. This should probably belong to the
    quick select
  */
  StringBuffer<64> mrr_type;
  
  Explain_quick_select *quick_info;

  bool using_where;
  Item *where_cond;

  ha_rows rows;

  bool using_io_buffer;

  /* Tracker for doing reads when filling the buffer */
  Table_access_tracker buf_tracker;
  
  bool is_using_filesort() { return filesort_tracker? true: false; }
  /*
    Non-null value of filesort_tracker means "using filesort"

    if we are using filesort, then table_tracker is for the io done inside
    filesort.
    
    'tracker' is for tracking post-filesort reads.
  */
  Filesort_tracker *filesort_tracker;

  /* ANALYZE members and methods */
  Table_access_tracker tracker;

  /* This tracks execution of the whole command */
  Time_and_counter_tracker command_tracker;
  
  /* TODO: This tracks time to read rows from the table */
  Exec_time_tracker table_tracker;

  /* The same as  Explain_table_access::handler_for_stats */
  handler *handler_for_stats;

  int print_explain(Explain_query *query, select_result_sink *output,
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer,
                          bool is_analyze) override;
};


/*
  EXPLAIN data structure for an INSERT.
  
  At the moment this doesn't do much as we don't really have any query plans
  for INSERT statements.
*/

class Explain_insert : public Explain_node
{
public:
  Explain_insert(MEM_ROOT *root) : 
  Explain_node(root)
  {}

  StringBuffer<64> table_name;

  enum explain_node_type get_type() override { return EXPLAIN_INSERT; }
  uint get_select_id() override { return 1; /* always root */ }

  int print_explain(Explain_query *query, select_result_sink *output,
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer,
                          bool is_analyze) override;
};


/* 
  EXPLAIN data of a single-table DELETE.
*/

class Explain_delete: public Explain_update
{
public:
  Explain_delete(MEM_ROOT *root, bool is_analyze) : 
  Explain_update(root, is_analyze)
  {}

  /*
    TRUE means we're going to call handler->delete_all_rows() and not read any
    rows.
  */
  bool deleting_all_rows;

  enum explain_node_type get_type() override { return EXPLAIN_DELETE; }
  uint get_select_id() override { return 1; /* always root */ }

  int print_explain(Explain_query *query, select_result_sink *output, 
                    uint8 explain_flags, bool is_analyze) override;
  void print_explain_json(Explain_query *query, Json_writer *writer,
                          bool is_analyze) override;
};


/*
  EXPLAIN data structure for subquery materialization.

  All decisions are made at execution time so here we just store the tracker
  that has all the info.
*/

class Explain_subq_materialization : public Sql_alloc
{
public:
  Explain_subq_materialization(MEM_ROOT *mem_root)
    : tracker(mem_root)
  {}

  Subq_materialization_tracker *get_tracker() { return &tracker; }

  void print_explain_json(Json_writer *writer, bool is_analyze);

private:
  Subq_materialization_tracker tracker;
};

#endif //SQL_EXPLAIN_INCLUDED

Edit Rename Chmod Delete

FILE FOLDER

Name	Size	Permission
atomic	---	0755
data	---	0755
aligned.h	1136bytes	0644
aria_backup.h	1547bytes	0644
assume_aligned.h	2350bytes	0644
authors.h	10141bytes	0644
backup.h	1703bytes	0644
bounded_queue.h	6093bytes	0644
client_settings.h	1935bytes	0644
compat56.h	2280bytes	0644
config.h	14574bytes	0644
contributors.h	4878bytes	0644
create_options.h	4524bytes	0644
create_tmp_table.h	2808bytes	0644
cset_narrowing.h	3968bytes	0644
custom_conf.h	1082bytes	0644
datadict.h	1700bytes	0644
ddl_log.h	12685bytes	0644
debug.h	1234bytes	0644
debug_sync.h	2046bytes	0644
derived_handler.h	2379bytes	0644
derror.h	980bytes	0644
des_key_file.h	1236bytes	0644
discover.h	1570bytes	0644
dur_prop.h	1082bytes	0644
embedded_priv.h	1733bytes	0644
event_data_objects.h	4187bytes	0644
event_db_repository.h	3648bytes	0644
event_parse_data.h	2899bytes	0644
event_queue.h	3438bytes	0644
event_scheduler.h	3290bytes	0644
events.h	4704bytes	0644
field.h	220767bytes	0644
field_comp.h	1174bytes	0644
filesort.h	7283bytes	0644
filesort_utils.h	8195bytes	0644
ft_global.h	3113bytes	0644
gcalc_slicescan.h	17272bytes	0644
gcalc_tools.h	11900bytes	0644
grant.h	2758bytes	0644
group_by_handler.h	3534bytes	0644
gstream.h	2437bytes	0644
ha_handler_stats.h	2335bytes	0644
ha_partition.h	64305bytes	0644
ha_sequence.h	6245bytes	0644
handle_connections_win.h	884bytes	0644
handler.h	201655bytes	0644
hash.h	4449bytes	0644
hash_filo.h	5688bytes	0644
heap.h	9480bytes	0644
hostname.h	5419bytes	0644
ilist.h	7135bytes	0644
init.h	852bytes	0644
innodb_priv.h	1319bytes	0644
item.h	280683bytes	0644
item_cmpfunc.h	135743bytes	0644
item_create.h	11501bytes	0644
item_func.h	138023bytes	0644
item_geofunc.h	39445bytes	0644
item_jsonfunc.h	22841bytes	0644
item_row.h	5229bytes	0644
item_strfunc.h	73367bytes	0644
item_subselect.h	59166bytes	0644
item_sum.h	72595bytes	0644
item_timefunc.h	65614bytes	0644
item_vers.h	4386bytes	0644
item_windowfunc.h	34508bytes	0644
item_xmlfunc.h	4633bytes	0644
json_table.h	9506bytes	0644
key.h	2132bytes	0644
keycaches.h	1995bytes	0644
lex.h	29569bytes	0644
lex_hash.h	142295bytes	0644
lex_ident.h	2122bytes	0644
lex_string.h	4068bytes	0644
lex_symbol.h	1323bytes	0644
lex_token.h	42502bytes	0644
lf.h	6462bytes	0644
lock.h	2203bytes	0644
log.h	46083bytes	0644
log_event.h	186410bytes	0644
log_event_data_type.h	1890bytes	0644
log_event_old.h	19830bytes	0644
log_slow.h	2442bytes	0644
maria.h	5872bytes	0644
mariadb.h	1277bytes	0644
mdl.h	38468bytes	0644
mem_root_array.h	7106bytes	0644
message.h	1195bytes	0644
multi_range_read.h	23179bytes	0644
my_alarm.h	2429bytes	0644
my_apc.h	4747bytes	0644
my_atomic.h	7281bytes	0644
my_atomic_wrapper.h	3051bytes	0644
my_base.h	27210bytes	0644
my_bit.h	6196bytes	0644
my_bitmap.h	5882bytes	0644
my_check_opt.h	2618bytes	0644
my_compare.h	11194bytes	0644
my_counter.h	1721bytes	0644
my_cpu.h	4855bytes	0644
my_crypt.h	904bytes	0644
my_decimal.h	14489bytes	0644
my_default.h	1880bytes	0644
my_handler_errors.h	4882bytes	0644
my_json_writer.h	18382bytes	0644
my_libwrap.h	1183bytes	0644
my_md5.h	1486bytes	0644
my_minidump.h	848bytes	0644
my_nosys.h	1438bytes	0644
my_rdtsc.h	8425bytes	0644
my_rnd.h	1064bytes	0644
my_service_manager.h	2050bytes	0644
my_stack_alloc.h	6493bytes	0644
my_stacktrace.h	3215bytes	0644
my_time.h	10414bytes	0644
my_tree.h	3991bytes	0644
my_uctype.h	69528bytes	0644
my_user.h	1126bytes	0644
myisam.h	17506bytes	0644
myisamchk.h	4716bytes	0644
myisammrg.h	4897bytes	0644
myisampack.h	14929bytes	0644
mysqld.h	40457bytes	0644
mysqld_default_groups.h	204bytes	0644
mysqld_suffix.h	1201bytes	0644
mysys_err.h	3022bytes	0644
opt_range.h	59591bytes	0644
opt_subselect.h	14551bytes	0644
opt_trace.h	8494bytes	0644
opt_trace_context.h	3291bytes	0644
parse_file.h	4387bytes	0644
partition_element.h	5209bytes	0644
partition_info.h	19300bytes	0644
password.h	1170bytes	0644
pfs_file_provider.h	3153bytes	0644
pfs_idle_provider.h	1385bytes	0644
pfs_memory_provider.h	1626bytes	0644
pfs_metadata_provider.h	1898bytes	0644
pfs_socket_provider.h	2258bytes	0644
pfs_stage_provider.h	1556bytes	0644
pfs_statement_provider.h	4347bytes	0644
pfs_table_provider.h	2625bytes	0644
pfs_thread_provider.h	5560bytes	0644
pfs_transaction_provider.h	2846bytes	0644
privilege.h	28642bytes	0644
probes_mysql.h	973bytes	0644
probes_mysql_nodtrace.h	6087bytes	0644
procedure.h	6819bytes	0644
protocol.h	12490bytes	0644
proxy_protocol.h	548bytes	0644
queues.h	3477bytes	0644
records.h	3147bytes	0644
repl_failsafe.h	1585bytes	0644
replication.h	16106bytes	0644
rijndael.h	1711bytes	0644
rowid_filter.h	15477bytes	0644
rpl_constants.h	3357bytes	0644
rpl_filter.h	4535bytes	0644
rpl_gtid.h	13683bytes	0644
rpl_injector.h	9621bytes	0644
rpl_mi.h	14991bytes	0644
rpl_parallel.h	17461bytes	0644
rpl_record.h	1585bytes	0644
rpl_record_old.h	1407bytes	0644
rpl_reporting.h	3713bytes	0644
rpl_rli.h	32746bytes	0644
rpl_tblmap.h	3177bytes	0644
rpl_utility.h	9630bytes	0644
scheduler.h	3199bytes	0644
scope.h	4393bytes	0644
select_handler.h	2228bytes	0644
semisync.h	2287bytes	0644
semisync_master.h	25766bytes	0644
semisync_master_ack_receiver.h	8709bytes	0644
semisync_slave.h	3733bytes	0644
service_versions.h	2049bytes	0644
session_tracker.h	14275bytes	0644
set_var.h	16551bytes	0644
slave.h	12275bytes	0644
socketpair.h	842bytes	0644
source_revision.h	67bytes	0644
sp.h	22588bytes	0644
sp_cache.h	2045bytes	0644
sp_head.h	64509bytes	0644
sp_pcontext.h	24897bytes	0644
sp_rcontext.h	14334bytes	0644
span.h	3931bytes	0644
spatial.h	22698bytes	0644
sql_acl.h	14132bytes	0644
sql_admin.h	2915bytes	0644
sql_alloc.h	1732bytes	0644
sql_alter.h	15277bytes	0644
sql_analyse.h	11125bytes	0644
sql_analyze_stmt.h	12681bytes	0644
sql_array.h	6875bytes	0644
sql_audit.h	13943bytes	0644
sql_base.h	25880bytes	0644
sql_basic_types.h	9528bytes	0644
sql_binlog.h	895bytes	0644
sql_bitmap.h	7845bytes	0644
sql_bootstrap.h	1812bytes	0644
sql_cache.h	21676bytes	0644
sql_callback.h	1542bytes	0644
sql_class.h	267426bytes	0644
sql_cmd.h	5212bytes	0644
sql_command.h	4804bytes	0644
sql_connect.h	4087bytes	0644
sql_const.h	11228bytes	0644
sql_crypt.h	1437bytes	0644
sql_cte.h	16533bytes	0644
sql_cursor.h	2316bytes	0644
sql_db.h	2440bytes	0644
sql_debug.h	5646bytes	0644
sql_delete.h	1343bytes	0644
sql_derived.h	1289bytes	0644
sql_digest.h	3819bytes	0644
sql_digest_stream.h	1567bytes	0644
sql_do.h	954bytes	0644
sql_error.h	39588bytes	0644
sql_explain.h	29020bytes	0644
sql_expression_cache.h	4359bytes	0644
sql_get_diagnostics.h	7867bytes	0644
sql_handler.h	2910bytes	0644
sql_help.h	995bytes	0644
sql_hset.h	3401bytes	0644
sql_i_s.h	8232bytes	0644
sql_insert.h	2651bytes	0644
sql_join_cache.h	48669bytes	0644
sql_lex.h	172548bytes	0644
sql_lifo_buffer.h	9676bytes	0644
sql_limit.h	3187bytes	0644
sql_list.h	22458bytes	0644
sql_load.h	1276bytes	0644
sql_locale.h	2701bytes	0644
sql_manager.h	960bytes	0644
sql_mode.h	6735bytes	0644
sql_parse.h	9135bytes	0644
sql_partition.h	12072bytes	0644
sql_partition_admin.h	5940bytes	0644
sql_plist.h	7732bytes	0644
sql_plugin.h	7549bytes	0644
sql_plugin_compat.h	2237bytes	0644
sql_prepare.h	11409bytes	0644
sql_priv.h	18593bytes	0644
sql_profile.h	7816bytes	0644
sql_reload.h	1036bytes	0644
sql_rename.h	982bytes	0644
sql_repl.h	3045bytes	0644
sql_schema.h	3303bytes	0644
sql_select.h	88898bytes	0644
sql_sequence.h	5180bytes	0644
sql_servers.h	1777bytes	0644
sql_show.h	9616bytes	0644
sql_signal.h	3362bytes	0644
sql_sort.h	21967bytes	0644
sql_statistics.h	12454bytes	0644
sql_string.h	39773bytes	0644
sql_table.h	9612bytes	0644
sql_tablespace.h	956bytes	0644
sql_test.h	1589bytes	0644
sql_time.h	8374bytes	0644
sql_trigger.h	12332bytes	0644
sql_truncate.h	2079bytes	0644
sql_tvc.h	2418bytes	0644
sql_type.h	295574bytes	0644
sql_type_fixedbin.h	64425bytes	0644
sql_type_fixedbin_storage.h	5467bytes	0644
sql_type_geom.h	19086bytes	0644
sql_type_int.h	10001bytes	0644
sql_type_json.h	6155bytes	0644
sql_type_real.h	1257bytes	0644
sql_type_string.h	1629bytes	0644
sql_udf.h	4850bytes	0644
sql_union.h	1064bytes	0644
sql_update.h	1923bytes	0644
sql_view.h	2470bytes	0644
sql_window.h	6814bytes	0644
ssl_compat.h	3147bytes	0644
strfunc.h	2275bytes	0644
structs.h	26379bytes	0644
sys_vars_shared.h	2729bytes	0644
t_ctype.h	5639bytes	0644
table.h	115905bytes	0644
table_cache.h	4232bytes	0644
thr_alarm.h	2932bytes	0644
thr_lock.h	7350bytes	0644
thr_malloc.h	1202bytes	0644
thr_timer.h	1563bytes	0644
thread_cache.h	5905bytes	0644
threadpool.h	4810bytes	0644
threadpool_generic.h	3969bytes	0644
threadpool_winsockets.h	2290bytes	0644
transaction.h	1466bytes	0644
tzfile.h	5014bytes	0644
tztime.h	3397bytes	0644
uniques.h	4217bytes	0644
unireg.h	7716bytes	0644
vers_string.h	2534bytes	0644
violite.h	10086bytes	0644
waiting_threads.h	4532bytes	0644
welcome_copyright_notice.h	1218bytes	0644
win_tzname_data.h	6506bytes	0644
winservice.h	1194bytes	0644
wqueue.h	1565bytes	0644
wsrep.h	3308bytes	0644
wsrep_applier.h	2703bytes	0644
wsrep_binlog.h	3441bytes	0644
wsrep_client_service.h	2560bytes	0644
wsrep_client_state.h	1566bytes	0644
wsrep_condition_variable.h	1484bytes	0644
wsrep_high_priority_service.h	4912bytes	0644
wsrep_mutex.h	1216bytes	0644
wsrep_mysqld.h	21370bytes	0644
wsrep_mysqld_c.h	1227bytes	0644
wsrep_on.h	1718bytes	0644
wsrep_priv.h	1634bytes	0644
wsrep_schema.h	4943bytes	0644
wsrep_server_service.h	3631bytes	0644
wsrep_server_state.h	2285bytes	0644
wsrep_sst.h	3951bytes	0644
wsrep_storage_service.h	1809bytes	0644
wsrep_thd.h	11160bytes	0644
wsrep_trans_observer.h	18119bytes	0644
wsrep_types.h	997bytes	0644
wsrep_utils.h	9290bytes	0644
wsrep_var.h	4607bytes	0644
wsrep_xid.h	1549bytes	0644
xa.h	1845bytes	0644

Command Bosku:

File Content: sql_explain.h

File Content: `sql_explain.h`