Query execution. More...

#include "sql/sql_executor.h"
#include <algorithm>
#include <atomic>
#include <cassert>
#include <cmath>
#include <cstddef>
#include <memory>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
#include "field_types.h"
#include "lex_string.h"
#include "m_ctype.h"
#include "mem_root_deque.h"
#include "my_alloc.h"
#include "my_base.h"
#include "my_bitmap.h"
#include "my_byteorder.h"
#include "my_checksum.h"
#include "my_dbug.h"
#include "my_loglevel.h"
#include "my_sqlcommand.h"
#include "my_sys.h"
#include "my_table_map.h"
#include "mysql/components/services/bits/psi_bits.h"
#include "mysql/components/services/log_builtins.h"
#include "mysqld_error.h"
#include "prealloced_array.h"
#include "sql/basic_row_iterators.h"
#include "sql/current_thd.h"
#include "sql/debug_sync.h"
#include "sql/enum_query_type.h"
#include "sql/field.h"
#include "sql/filesort.h"
#include "sql/handler.h"
#include "sql/item.h"
#include "sql/item_cmpfunc.h"
#include "sql/item_func.h"
#include "sql/item_sum.h"
#include "sql/join_optimizer/access_path.h"
#include "sql/join_optimizer/bit_utils.h"
#include "sql/join_optimizer/estimate_filter_cost.h"
#include "sql/join_optimizer/join_optimizer.h"
#include "sql/join_optimizer/materialize_path_parameters.h"
#include "sql/join_optimizer/relational_expression.h"
#include "sql/join_optimizer/walk_access_paths.h"
#include "sql/join_type.h"
#include "sql/json_dom.h"
#include "sql/key.h"
#include "sql/key_spec.h"
#include "sql/mem_root_array.h"
#include "sql/mysqld.h"
#include "sql/nested_join.h"
#include "sql/opt_costmodel.h"
#include "sql/opt_explain_format.h"
#include "sql/opt_range.h"
#include "sql/opt_trace.h"
#include "sql/opt_trace_context.h"
#include "sql/query_options.h"
#include "sql/record_buffer.h"
#include "sql/records.h"
#include "sql/ref_row_iterators.h"
#include "sql/row_iterator.h"
#include "sql/sort_param.h"
#include "sql/sql_array.h"
#include "sql/sql_base.h"
#include "sql/sql_bitmap.h"
#include "sql/sql_class.h"
#include "sql/sql_const.h"
#include "sql/sql_join_buffer.h"
#include "sql/sql_list.h"
#include "sql/sql_optimizer.h"
#include "sql/sql_resolver.h"
#include "sql/sql_select.h"
#include "sql/sql_tmp_table.h"
#include "sql/table.h"
#include "sql/temp_table_param.h"
#include "sql/timing_iterator.h"
#include "sql/visible_fields.h"
#include "sql/window.h"
#include "sql_string.h"
#include "tables_contained_in.h"
#include "template_utils.h"
#include "thr_lock.h"

Classes
struct	PendingInvalidator
	Cache invalidator iterators we need to apply, but cannot yet due to outer joins. More...

Enumerations
enum	CallingContext { TOP_LEVEL , DIRECTLY_UNDER_SEMIJOIN , DIRECTLY_UNDER_OUTER_JOIN , DIRECTLY_UNDER_WEEDOUT }

enum class	Substructure { NONE , OUTER_JOIN , SEMIJOIN , WEEDOUT }

Functions
static int	read_system (TABLE *table)
	Read a constant table when there is at most one matching row, using a table scan. More...

static int	read_const (TABLE table, TABLE_REF ref)

static bool	alloc_group_fields (JOIN join, ORDER group)
	Get a list of buffers for saveing last group. More...

static pair< uchar *, key_part_map >	FindKeyBufferAndMap (const TABLE_REF *ref)

string	RefToString (const TABLE_REF &ref, const KEY *key, bool include_nulls)

bool	has_rollup_result (Item *item)
	Checks if an item has a ROLLUP NULL which needs to be written to temp table. More...

bool	is_rollup_group_wrapper (Item *item)

bool	is_rollup_sum_wrapper (Item *item)

Item *	unwrap_rollup_group (Item *item)

bool	prepare_sum_aggregators (Item_sum **sum_funcs, bool need_distinct)

bool	setup_sum_funcs (THD thd, Item_sum *func_ptr)
	Call `setup()` for all sum functions. More...

void	init_tmptable_sum_functions (Item_sum **func_ptr)

void	update_tmptable_sum_func (Item_sum *func_ptr, TABLE tmp_table)
	Update record 0 in tmp_table from record 1. More...

bool	copy_funcs (Temp_table_param param, const THD thd, Copy_func_type type)
	Copy result of functions to record in tmp_table. More...

static bool	update_const_equal_items (THD thd, Item cond, JOIN_TAB *tab)
	Check appearance of new constant items in multiple equalities of a condition after reading a constant table. More...

void	setup_tmptable_write_func (QEP_TAB tab, Opt_trace_object trace)
	Setup write_func of QEP_tmp_table object. More...

static size_t	record_prefix_size (const TABLE *table)
	Find out how many bytes it takes to store the smallest prefix which covers all the columns that will be read from a table. More...

bool	set_record_buffer (TABLE *table, double expected_rows_to_fetch)
	Allocate a data buffer that the storage engine can use for fetching batches of records. More...

void	ExtractConditions (Item condition, Mem_root_array< Item > *condition_parts)
	Split AND conditions into their constituent parts, recursively. More...

static bool	ContainsAnyMRRPaths (AccessPath *path)
	See if “path” has any MRR nodes; if so, we cannot optimize them away in PossiblyAttachFilter(), as the BKA iterator expects there to be a corresponding MRR iterator. More...

AccessPath *	PossiblyAttachFilter (AccessPath path, const vector< Item > &conditions, THD thd, table_map conditions_depend_on_outer_tables)
	Return a new iterator that wraps "iterator" and that tests all of the given conditions (if any), ANDed together. More...

AccessPath *	CreateNestedLoopAccessPath (THD thd, AccessPath outer, AccessPath *inner, JoinType join_type, bool pfs_batch_mode)

static AccessPath *	NewInvalidatorAccessPathForTable (THD thd, AccessPath path, QEP_TAB *qep_tab, plan_idx table_index_to_invalidate)

static table_map	ConvertQepTabMapToTableMap (JOIN *join, qep_tab_map tables)

AccessPath *	CreateBKAAccessPath (THD thd, JOIN join, AccessPath outer_path, qep_tab_map left_tables, AccessPath inner_path, qep_tab_map right_tables, TABLE table, TABLE_LIST table_list, TABLE_REF *ref, JoinType join_type)

static AccessPath *	PossiblyAttachFilter (AccessPath path, const vector< PendingCondition > &conditions, THD thd, table_map *conditions_depend_on_outer_tables)

static Item_func_trig_cond *	GetTriggerCondOrNull (Item *item)

void	ConvertItemsToCopy (const mem_root_deque< Item * > &items, Field *fields, Temp_table_param param)
	For historical reasons, derived table materialization and temporary table materialization didn't specify the fields to materialize in the same way. More...

static bool	IsJoinCondition (const Item item, const QEP_TAB qep_tab)

static Item *	GetInnermostCondition (Item *item)

void	SplitConditions (Item condition, QEP_TAB current_table, vector< Item * > predicates_below_join, vector< PendingCondition > predicates_above_join, vector< PendingCondition > *join_conditions)

static void	MarkUnhandledDuplicates (SJ_TMP_TABLE weedout, plan_idx weedout_start, plan_idx weedout_end, qep_tab_map unhandled_duplicates)
	For a given duplicate weedout operation, figure out which tables are supposed to be deduplicated by it, and add those to unhandled_duplicates. More...

static AccessPath *	CreateWeedoutOrLimitAccessPath (THD thd, AccessPath path, SJ_TMP_TABLE *weedout_table)

static AccessPath *	NewWeedoutAccessPathForTables (THD thd, const qep_tab_map tables_to_deduplicate, QEP_TAB qep_tabs, uint primary_tables, AccessPath *path)

static Substructure	FindSubstructure (QEP_TAB qep_tabs, const plan_idx first_idx, const plan_idx this_idx, const plan_idx last_idx, CallingContext calling_context, bool add_limit_1, plan_idx substructure_end, qep_tab_map unhandled_duplicates)
	Given a range of tables (where we assume that we've already handled first_idx..(this_idx-1) as inner joins), figure out whether this is a semijoin, an outer join or a weedout. More...

static bool	IsTableScan (AccessPath *path)

AccessPath *	GetAccessPathForDerivedTable (THD thd, QEP_TAB qep_tab, AccessPath *table_path)

AccessPath *	GetAccessPathForDerivedTable (THD thd, TABLE_LIST table_ref, TABLE table, bool rematerialize, Mem_root_array< const AccessPath > invalidators, bool need_rowid, AccessPath table_path)

AccessPath *	GetTableAccessPath (THD thd, QEP_TAB qep_tab, QEP_TAB *qep_tabs)
	Get the RowIterator used for scanning the given table, with any required materialization operations done first. More...

void	SetCostOnTableAccessPath (const Cost_model_server &cost_model, const POSITION pos, bool is_after_filter, AccessPath path)

void	SetCostOnNestedLoopAccessPath (const Cost_model_server &cost_model, const POSITION pos_inner, AccessPath path)

void	SetCostOnHashJoinAccessPath (const Cost_model_server &cost_model, const POSITION pos_outer, AccessPath path)

static bool	ConditionIsAlwaysTrue (Item *item)

static bool	ItemRefersToOneSideOnly (Item *item, table_map left_side, table_map right_side)

static AccessPath *	CreateHashJoinAccessPath (THD thd, QEP_TAB qep_tab, AccessPath build_path, qep_tab_map build_tables, AccessPath probe_path, qep_tab_map probe_tables, JoinType join_type, vector< Item * > join_conditions, table_map conditions_depend_on_outer_tables)

static void	ExtractJoinConditions (const QEP_TAB current_table, vector< Item > predicates, vector< Item > *join_conditions)

static bool	SubtreeHasIncompletePushedJoin (JOIN *join, qep_tab_map subtree)

static bool	PushedJoinRejectsHashJoin (JOIN *join, qep_tab_map left_subtree, qep_tab_map right_subtree, JoinType join_type)

static bool	UseHashJoin (QEP_TAB *qep_tab)

static bool	UseBKA (QEP_TAB *qep_tab)

static bool	QueryMixesOuterBKAAndBNL (JOIN *join)

static bool	InsideOuterOrAntiJoin (QEP_TAB *qep_tab)

void	PickOutConditionsForTableIndex (int table_idx, vector< PendingCondition > from, vector< PendingCondition > to)

void	PickOutConditionsForTableIndex (int table_idx, vector< PendingCondition > from, vector< Item > *to)

AccessPath *	FinishPendingOperations (THD thd, AccessPath path, QEP_TAB remove_duplicates_loose_scan_qep_tab, const vector< PendingCondition > &pending_conditions, table_map conditions_depend_on_outer_tables)

static AccessPath *	ConnectJoins (plan_idx upper_first_idx, plan_idx first_idx, plan_idx last_idx, QEP_TAB qep_tabs, THD thd, CallingContext calling_context, vector< PendingCondition > pending_conditions, vector< PendingInvalidator > pending_invalidators, vector< PendingCondition > pending_join_conditions, qep_tab_map unhandled_duplicates, table_map *conditions_depend_on_outer_tables)
	For a given slice of the table list, build up the iterator tree corresponding to the tables in that slice. More...

int	do_sj_dups_weedout (THD thd, SJ_TMP_TABLE sjtbl)
	SemiJoinDuplicateElimination: Weed out duplicate row combinations. More...

int	report_handler_error (TABLE *table, int error)
	Help function when we get some an error from the table handler. More...

static bool	init_index (TABLE table, handler file, uint idx, bool sorted)
	Initialize an index scan. More...

int	safe_index_read (QEP_TAB *tab)

int	join_read_const_table (JOIN_TAB tab, POSITION pos)
	Reads content of constant table. More...

ulonglong	get_exact_record_count (QEP_TAB qep_tab, uint table_count, int error)
	Get exact count of rows in all tables. More...

static bool	cmp_field_value (Field *field, ptrdiff_t diff)

static bool	group_rec_cmp (ORDER group, uchar rec0, uchar *rec1)
	Compare GROUP BY in from tmp table's record[0] and record[1]. More...

static bool	table_rec_cmp (TABLE *table)
	Compare GROUP BY in from tmp table's record[0] and record[1]. More...

ulonglong	unique_hash (const Field field, ulonglong hash_val)
	Generate hash for a field. More...

static ulonglong	unique_hash_group (ORDER *group)
	Generate hash for unique constraint according to group-by list. More...

static ulonglong	unique_hash_fields (TABLE *table)

bool	check_unique_constraint (TABLE *table)
	Check unique_constraint. More...

bool	construct_lookup_ref (THD thd, TABLE table, TABLE_REF *ref)
	Copy the lookup key into the table ref's key buffer. More...

bool	make_group_fields (JOIN main_join, JOIN curr_join)
	allocate group fields or take prepared (cached). More...

int	update_item_cache_if_changed (List< Cached_item > &list)

static size_t	compute_ria_idx (const mem_root_deque< Item * > &fields, size_t i, size_t added_non_hidden_fields, size_t border)
	Compute the position mapping from fields to ref_item_array, cf. More...

bool	copy_fields (Temp_table_param param, const THD thd, bool reverse_copy)
	Make a copy of all simple SELECT'ed fields. More...

static bool	replace_embedded_rollup_references_with_tmp_fields (THD thd, Item item, mem_root_deque< Item * > *fields)
	For each rollup wrapper below the given item, replace it with a temporary field, e.g. More...

bool	change_to_use_tmp_fields (mem_root_deque< Item * > fields, THD thd, Ref_item_array ref_item_array, mem_root_deque< Item * > *res_fields, size_t added_non_hidden_fields)
	Change all funcs and sum_funcs to fields in tmp table, and create new list of all items. More...

bool	replace_contents_of_rollup_wrappers_with_tmp_fields (THD thd, Query_block select, Item *item_arg)
	For each rollup wrapper below the given item, replace its argument with a temporary field, e.g. More...

bool	change_to_use_tmp_fields_except_sums (mem_root_deque< Item * > fields, THD thd, Query_block select, Ref_item_array ref_item_array, mem_root_deque< Item > *res_fields, size_t added_non_hidden_fields)
	Change all sum_func refs to fields to point at fields in tmp table. More...

bool	MaterializeIsDoingDeduplication (TABLE *table)

Variables
static constexpr size_t	MAX_RECORD_BUFFER_SIZE = 128 * 1024
	Maximum amount of space (in bytes) to allocate for a Record_buffer. More...

Classes

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ MaterializeIsDoingDeduplication()