MySQL 8.4.0
Source Code Documentation
sql_select.h File Reference
#include <assert.h>
#include <sys/types.h>
#include <climits>
#include <string_view>
#include "my_base.h"
#include "my_inttypes.h"
#include "my_sqlcommand.h"
#include "my_table_map.h"
#include "sql/field.h"
#include "sql/handler.h"
#include "sql/item_cmpfunc.h"
#include "sql/opt_costmodel.h"
#include "sql/sql_bitmap.h"
#include "sql/sql_cmd_dml.h"
#include "sql/sql_const.h"
#include "sql/sql_opt_exec_shared.h"

Go to the source code of this file.


class  Sql_cmd_select
class  Key_use
 A Key_use represents an equality predicate of the form (table.column = val), where the column is indexed by keypart in key and val is either a constant, a column from other table, or an expression over column(s) from other table(s). More...
struct  POSITION
 A position of table within a join order. More...
class  JOIN_TAB
 Query optimization plan node. More...
class  store_key
 class to copying an field/item to a key struct More...
class  store_key_hash_item


#define LOWER_BITS(type, A)   ((type)(((type)1 << (A)) - 1))
 Returns a constant of type 'type' with the 'A' lowest-weight bits set. More...
#define FT_KEYPART   (MAX_REF_PARTS + 10)
#define SJ_OPT_NONE   0
#define SJ_OPT_LOOSE_SCAN   2
#define SJ_OPT_FIRST_MATCH   3


typedef ulonglong nested_join_map
typedef Mem_root_array< Func_ptrFunc_ptr_array


enum  quick_type { QS_NONE , QS_RANGE , QS_DYNAMIC_RANGE }
 Bits describing quick select type. More...
enum  aggregate_evaluated { AGGR_COMPLETE , AGGR_REGULAR , AGGR_DELAYED , AGGR_EMPTY }


join_type calc_join_type (AccessPath *path)
bool sj_is_materialize_strategy (uint strategy)
void count_field_types (const Query_block *query_block, Temp_table_param *param, const mem_root_deque< Item * > &fields, bool reset_with_sum_func, bool save_sum_fields)
 Update TMP_TABLE_PARAM with count of the different type of fields. More...
uint find_shortest_key (TABLE *table, const Key_map *usable_keys)
 Find shortest key suitable for full table scan. More...
bool is_simple_predicate (Item_func *func_item, Item **args, bool *inv_order)
 Test if the predicate compares a field with constants. More...
bool optimize_aggregated_query (THD *thd, Query_block *select, const mem_root_deque< Item * > &all_fields, Item *conds, aggregate_evaluated *decision)
 Substitute constants for some COUNT(), MIN() and MAX() functions in an aggregated (implicitly grouped) query. More...
int refpos_order_cmp (const void *arg, const void *a, const void *b)
bool check_privileges_for_join (THD *thd, mem_root_deque< Table_ref * > *tables)
 Check privileges for all columns referenced from join expression. More...
bool check_privileges_for_list (THD *thd, const mem_root_deque< Item * > &items, ulong privileges)
 Check privileges for all columns referenced from an expression list. More...
bool set_statement_timer (THD *thd)
 Set the time until the currently running statement is aborted. More...
void reset_statement_timer (THD *thd)
 Deactivate the timer associated with the statement that was executed. More...
void free_underlaid_joins (Query_block *select)
 Free joins of subselect of this select. More...
void calc_used_field_length (TABLE *table, bool needs_rowid, uint *p_used_fieldlength)
 Find how much space the previous read not const tables takes in cache. More...
ORDERsimple_remove_const (ORDER *order, Item *where)
 Filter out ORDER BY items that are equal to constants in WHERE condition. More...
bool check_field_is_const (Item *cond, const Item *order_item, const Field *order_field=nullptr, Item **const_item=nullptr)
 Check if a field is equal to a constant value in a condition. More...
bool test_if_subpart (ORDER *a, ORDER *b)
 Return 1 if second is a subpart of first argument. More...
void calc_group_buffer (JOIN *join, ORDER *group)
 calc how big buffer we need for comparing group entries. More...
bool make_join_readinfo (JOIN *join, uint no_jbuf_after)
 Plan refinement stage: do various setup things for the executor. More...
bool create_ref_for_key (JOIN *join, JOIN_TAB *j, Key_use *org_keyuse, table_map used_tables)
 Setup a ref access for looking up rows via an index (a key). More...
bool types_allow_materialization (Item *outer, Item *inner)
 Check if two items are compatible wrt. More...
bool and_conditions (Item **e1, Item *e2)
 Extend e1 by AND'ing e2 to the condition e1 points to. More...
static Itemand_items (Item *cond, Item *item)
 Create a AND item of two existing items. More...
static Item_bool_funcand_items (Item *cond, Item_bool_func *item)
 A variant of the above, guaranteed to return Item_bool_func. More...
uint actual_key_parts (const KEY *key_info)
 Returns number of key parts depending on OPTIMIZER_SWITCH_USE_INDEX_EXTENSIONS flag. More...
uint get_index_for_order (ORDER_with_src *order, TABLE *table, ha_rows limit, AccessPath *range_scan, bool *need_sort, bool *reverse)
 Find a key to apply single table UPDATE/DELETE by a given ORDER. More...
int test_if_order_by_key (ORDER_with_src *order, TABLE *table, uint idx, uint *used_key_parts, bool *skip_quick)
 Test if one can use the key to resolve ordering. More...
bool test_if_cheaper_ordering (const JOIN_TAB *tab, ORDER_with_src *order, TABLE *table, Key_map usable_keys, int key, ha_rows select_limit, int *new_key, int *new_key_direction, ha_rows *new_select_limit, uint *new_used_key_parts=nullptr, uint *saved_best_key_parts=nullptr)
 Find a cheaper access key than a given key. More...
void calc_length_and_keyparts (Key_use *keyuse, JOIN_TAB *tab, const uint key, table_map used_tables, Key_use **chosen_keyuses, uint *length_out, uint *keyparts_out, table_map *dep_map, bool *maybe_null)
 Calculate properties of ref key: key length, number of used key parts, dependency map, possibility of null. More...
bool init_ref (THD *thd, unsigned keyparts, unsigned length, unsigned keyno, Index_lookup *ref)
 Initialize the given TABLE_REF; setting basic fields and allocating memory for arrays. More...
bool init_ref_part (THD *thd, unsigned part_no, Item *val, bool *cond_guard, bool null_rejecting, table_map const_tables, table_map used_tables, bool nullable, const KEY_PART_INFO *key_part_info, uchar *key_buff, Index_lookup *ref)
 Initialize a given keypart in the table ref. More...
SJ_TMP_TABLEcreate_sj_tmp_table (THD *thd, JOIN *join, SJ_TMP_TABLE_TAB *first_tab, SJ_TMP_TABLE_TAB *last_tab)
 Set up the support structures (NULL bits, row offsets, etc.) for a semijoin duplicate weedout table. More...
uint actual_key_flags (const KEY *key_info)
 Returns key flags depending on OPTIMIZER_SWITCH_USE_INDEX_EXTENSIONS flag. More...
bool equality_determines_uniqueness (const Item_func_comparison *func, const Item *v, const Item *c)
 Check if equality can be used to remove sub-clause of GROUP BY/ORDER BY. More...
bool equality_has_no_implicit_casts (const Item_func_comparison *func, const Item *item1, const Item *item2)
 Check whether equality between two items is exact, ie., there are no implicit casts involved. More...
bool CreateFramebufferTable (THD *thd, const Temp_table_param &tmp_table_param, const Query_block &query_block, const mem_root_deque< Item * > &source_fields, const mem_root_deque< Item * > &window_output_fields, Func_ptr_array *mapping_from_source_to_window_output, Window *window)
bool validate_use_secondary_engine (const LEX *lex)
 Validates a query that uses the secondary engine. More...
bool optimize_secondary_engine (THD *thd)
 Perform query optimizations that are specific to a secondary storage engine. More...
void accumulate_statement_cost (const LEX *lex)
 Calculates the cost of executing a statement, including all its subqueries and stores it in thd->m_current_query_cost. More...
const handlertonget_secondary_engine_handlerton (const LEX *lex)
 Returns secondary_engine handler for the statement. More...
bool has_external_table (const LEX *lex)
 Checks if any of the tables referenced belong to an external engine. More...
void set_external_engine_fail_reason (const LEX *lex, const char *reason)
 Sets the reason of failure for the statement to the external engine. More...
void notify_plugins_after_select (THD *thd, const Sql_cmd *cmd)
 Notify plugins about an executed SELECT statement. More...
std::string_view get_secondary_engine_fail_reason (const LEX *lex)
void set_fail_reason_and_raise_error (const LEX *lex, std::string_view reason)
const MYSQL_LEX_CSTRINGget_eligible_secondary_engine_from (const LEX *lex)
std::string_view find_secondary_engine_fail_reason (const LEX *lex)
void find_and_set_offload_fail_reason (const LEX *lex)
bool reads_not_secondary_columns (const LEX *lex)
 Checks if a query reads a column that is not available in the secondary engine (i.e. More...


constexpr const char * STORE_KEY_CONST_NAME = "const"
 The name of store_key instances that represent constant items. More...

Macro Definition Documentation


#define FT_KEYPART   (MAX_REF_PARTS + 10)






#define LOWER_BITS (   type,
)    ((type)(((type)1 << (A)) - 1))

Returns a constant of type 'type' with the 'A' lowest-weight bits set.

Example: LOWER_BITS(uint, 3) == 7. Requirement: A < sizeof(type) * 8.




#define SJ_OPT_FIRST_MATCH   3


#define SJ_OPT_LOOSE_SCAN   2






#define SJ_OPT_NONE   0

Typedef Documentation

◆ Func_ptr_array

◆ nested_join_map

Enumeration Type Documentation

◆ aggregate_evaluated


◆ quick_type

enum quick_type

Bits describing quick select type.


Function Documentation

◆ and_items() [1/2]

static Item * and_items ( Item cond,
Item item 

Create a AND item of two existing items.

A new Item_cond_and item is created with the two supplied items as arguments.

About handling of null pointers as arguments: if the first argument is a null pointer, then the item given as second argument is returned (no new Item_cond_and item is created). The second argument must not be a null pointer.
condthe first argument to the new AND condition
itemthe second argument to the new AND condition
the new AND item

◆ and_items() [2/2]

static Item_bool_func * and_items ( Item cond,
Item_bool_func item 

A variant of the above, guaranteed to return Item_bool_func.

◆ is_simple_predicate()

bool is_simple_predicate ( Item_func func_item,
Item **  args,
bool *  inv_order 

Test if the predicate compares a field with constants.

func_itemPredicate item
[out]argsHere we store the field followed by constants
[out]inv_orderIs set to true if the predicate is of the form 'const op field'
true if function is a simple predicate, false otherwise.

◆ optimize_aggregated_query()

bool optimize_aggregated_query ( THD thd,
Query_block select,
const mem_root_deque< Item * > &  fields,
Item conds,
aggregate_evaluated decision 

Substitute constants for some COUNT(), MIN() and MAX() functions in an aggregated (implicitly grouped) query.

[in]thdthread handler
[in]selectquery block
[in]fieldsAll fields to be returned
[in]condsWHERE clause
[out]decisionoutcome for successful execution = AGGR_REGULAR regular execution required = AGGR_COMPLETE values available = AGGR_DELAYED execution with ha_records() required = AGGR_EMPTY source tables empty, aggregates are NULL or zero (for COUNT)
false if success, true if error

This function is called for queries with aggregate functions and no GROUP BY, thus the result set will contain a single row only.

First, the function will analyze the source tables and WHERE clause to see whether the query qualifies for optimization. If not, the decision AGGR_REGULAR is returned.

Second, the function walks over all expressions in the SELECT list. If the expression can be optimized with a storage engine operation that is O(1) (MIN or MAX) or O(0) (instant COUNT), the value is looked up and inserted in the value buffer, and the corresponding Item is marked as being const. If the expression is a COUNT operation that can be evaluated efficiently by the storage manager (but still O(N)), indicated with HA_COUNT_ROWS_INSTANT, it will be marked as such.

When all SELECT list expressions have been processed, there are four possible outcomes:

  • An empty result from the source tables is indicated, and the output state is AGGR_EMPTY. Notice that the result of aggregation is still one row, filled with zero for COUNT operations and NULL values for all other expressions.
  • All expressions have been given values, indicated with output state AGGR_COMPLETE.
  • All expressions have been given values, except for one or more COUNT operations that will be evaluated in execution. This is indicated with AGGR_DELAYED.
  • Some expressions must be evaluated as part of a regular execution, indicated with AGGR_REGULAR. Notice that some of the expressions may have been given values and are marked as const, but no expressions will be candidates for delayed execution.

◆ refpos_order_cmp()

int refpos_order_cmp ( const void *  arg,
const void *  a,
const void *  b 

◆ set_external_engine_fail_reason()

void set_external_engine_fail_reason ( const LEX lex,
const char *  reason 

Sets the reason of failure for the statement to the external engine.

lexthe statement
reasonthe reason of failure

◆ sj_is_materialize_strategy()

bool sj_is_materialize_strategy ( uint  strategy)

Variable Documentation


constexpr const char* STORE_KEY_CONST_NAME = "const"

The name of store_key instances that represent constant items.