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.

Classes
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

Macros
#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	KEY_OPTIMIZE_EXISTS   1
#define	KEY_OPTIMIZE_REF_OR_NULL   2
#define	FT_KEYPART   (MAX_REF_PARTS + 10)
#define	SJ_OPT_NONE   0
#define	SJ_OPT_DUPS_WEEDOUT   1
#define	SJ_OPT_LOOSE_SCAN   2
#define	SJ_OPT_FIRST_MATCH   3
#define	SJ_OPT_MATERIALIZE_LOOKUP   4
#define	SJ_OPT_MATERIALIZE_SCAN   5

Typedefs
typedef ulonglong	nested_join_map
typedef Mem_root_array< Func_ptr >	Func_ptr_array

Enumerations
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 }

Functions
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...
ORDER *	simple_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 Item *	and_items (Item *cond, Item *item)
	Create a AND item of two existing items. More...
static Item_bool_func *	and_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_TABLE *	create_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 handlerton *	get_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_CSTRING *	get_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...

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

Macro Definition Documentation

FT_KEYPART

#define FT_KEYPART   (MAX_REF_PARTS + 10)

KEY_OPTIMIZE_EXISTS

#define KEY_OPTIMIZE_EXISTS   1

KEY_OPTIMIZE_REF_OR_NULL

#define KEY_OPTIMIZE_REF_OR_NULL   2

LOWER_BITS

#define LOWER_BITS	(		type,
			A
	)		((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.

SJ_OPT_DUPS_WEEDOUT

#define SJ_OPT_DUPS_WEEDOUT   1

SJ_OPT_FIRST_MATCH

#define SJ_OPT_FIRST_MATCH   3

SJ_OPT_LOOSE_SCAN

#define SJ_OPT_LOOSE_SCAN   2

SJ_OPT_MATERIALIZE_LOOKUP

#define SJ_OPT_MATERIALIZE_LOOKUP   4

SJ_OPT_MATERIALIZE_SCAN

#define SJ_OPT_MATERIALIZE_SCAN   5

SJ_OPT_NONE

#define SJ_OPT_NONE   0

Typedef Documentation

Func_ptr_array

typedef Mem_root_array<Func_ptr> Func_ptr_array

nested_join_map

typedef ulonglong nested_join_map

Enumeration Type Documentation

aggregate_evaluated

enum aggregate_evaluated

Enumerator
AGGR_COMPLETE
AGGR_REGULAR
AGGR_DELAYED
AGGR_EMPTY

quick_type

enum quick_type

Bits describing quick select type.

Enumerator
QS_NONE
QS_RANGE
QS_DYNAMIC_RANGE

Function Documentation

and_items() [1/2]

static Item * and_items ( Item *  cond, Item *  item  )

inlinestatic

Create a AND item of two existing items.

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

Note

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.

Parameters

cond	the first argument to the new AND condition
item	the second argument to the new AND condition

Returns

the new AND item

and_items() [2/2]

static Item_bool_func * and_items ( Item *  cond, Item_bool_func *  item  )

inlinestatic

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.

Parameters

	func_item	Predicate item
[out]	args	Here we store the field followed by constants
[out]	inv_order	Is set to true if the predicate is of the form 'const op field'

Returns

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.

Parameters

[in]	thd	thread handler
[in]	select	query block
[in]	fields	All fields to be returned
[in]	conds	WHERE clause
[out]	decision	outcome 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)

Returns

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.

Parameters

lex	the statement
reason	the reason of failure

sj_is_materialize_strategy()

bool sj_is_materialize_strategy ( uint  strategy )

inline

Variable Documentation

STORE_KEY_CONST_NAME

constexpr const char* STORE_KEY_CONST_NAME = "const"

constexpr

The name of store_key instances that represent constant items.