#include "sql/sql_update.h"
#include <algorithm>
#include <atomic>
#include <cassert>
#include <cstdio>
#include <cstring>
#include <memory>
#include <utility>
#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_bit.h"
#include "my_bitmap.h"
#include "my_dbug.h"
#include "my_inttypes.h"
#include "my_io.h"
#include "my_sys.h"
#include "my_table_map.h"
#include "mysql/components/services/bits/psi_bits.h"
#include "mysql/service_mysql_alloc.h"
#include "mysql_com.h"
#include "mysqld_error.h"
#include "prealloced_array.h"
#include "scope_guard.h"
#include "sql/auth/auth_acls.h"
#include "sql/auth/auth_common.h"
#include "sql/binlog.h"
#include "sql/debug_sync.h"
#include "sql/derror.h"
#include "sql/field.h"
#include "sql/filesort.h"
#include "sql/handler.h"
#include "sql/item.h"
#include "sql/item_json_func.h"
#include "sql/item_subselect.h"
#include "sql/iterators/basic_row_iterators.h"
#include "sql/iterators/row_iterator.h"
#include "sql/iterators/timing_iterator.h"
#include "sql/iterators/update_rows_iterator.h"
#include "sql/join_optimizer/access_path.h"
#include "sql/join_optimizer/bit_utils.h"
#include "sql/join_optimizer/walk_access_paths.h"
#include "sql/key.h"
#include "sql/key_spec.h"
#include "sql/locked_tables_list.h"
#include "sql/mdl.h"
#include "sql/mem_root_array.h"
#include "sql/mysqld.h"
#include "sql/opt_explain.h"
#include "sql/opt_explain_format.h"
#include "sql/opt_trace.h"
#include "sql/opt_trace_context.h"
#include "sql/parse_tree_node_base.h"
#include "sql/partition_info.h"
#include "sql/protocol.h"
#include "sql/psi_memory_key.h"
#include "sql/query_options.h"
#include "sql/range_optimizer/partition_pruning.h"
#include "sql/range_optimizer/path_helpers.h"
#include "sql/range_optimizer/range_optimizer.h"
#include "sql/select_lex_visitor.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_data_change.h"
#include "sql/sql_delete.h"
#include "sql/sql_error.h"
#include "sql/sql_executor.h"
#include "sql/sql_lex.h"
#include "sql/sql_list.h"
#include "sql/sql_opt_exec_shared.h"
#include "sql/sql_optimizer.h"
#include "sql/sql_partition.h"
#include "sql/sql_resolver.h"
#include "sql/sql_select.h"
#include "sql/sql_tmp_table.h"
#include "sql/sql_view.h"
#include "sql/system_variables.h"
#include "sql/table.h"
#include "sql/table_trigger_dispatcher.h"
#include "sql/temp_table_param.h"
#include "sql/thd_raii.h"
#include "sql/transaction_info.h"
#include "sql/trigger_chain.h"
#include "sql/trigger_def.h"
#include "sql/visible_fields.h"
#include "template_utils.h"
#include "thr_lock.h"

Functions
static bool	prepare_partial_update (Opt_trace_context trace, const mem_root_deque< Item > &fields, const mem_root_deque< Item * > &values)
	Mark the columns that can possibly be updated in-place using partial update. More...

bool	records_are_comparable (const TABLE *table)
	True if the table's input and output record buffers are comparable using compare_records(TABLE*). More...

bool	compare_records (const TABLE *table)
	Compares the input and output record buffers of the table to see if a row has changed. More...

static bool	check_constant_expressions (const mem_root_deque< Item * > &values)
	Check if all expressions in list are constant expressions. More...

static table_map	get_table_map (const mem_root_deque< Item * > &items)

static TABLE *	GetOutermostTable (const JOIN *join)
	Returns the outermost (leftmost) table of a join. More...

static bool	unsafe_key_update (Table_ref *leaves, table_map tables_for_update)
	If one row is updated through two different aliases and the first update physically moves the row, the second update will error because the row is no longer located where expected. More...

static bool	has_json_columns (const mem_root_deque< Item * > &items)
	Check if a list of Items contains an Item whose type is JSON. More...

bool	should_switch_to_multi_table_if_subqueries (const THD thd, const Query_block select, const Table_ref *table_list)
	Decides if a single-table UPDATE/DELETE statement should switch to the multi-table code path, if there are subqueries which might benefit from semijoin or subquery materialization, and if no feature specific to the single-table path are used. More...

static void	CollectColumnsReferencedInJoinConditions (const JOIN join, const Table_ref table_ref)

static bool	safe_update_on_fly (const QEP_TAB join_tab, const Table_ref table_ref, Table_ref *all_tables)
	Check if table is safe to update on the fly. More...

static bool	AddRowIdAsTempTableField (THD thd, TABLE table, mem_root_deque< Item * > *fields)
	Adds a field for storing row IDs from "table" to "fields". More...

static void	StoreRowId (TABLE table, TABLE tmp_table, int field_num, table_map hash_join_tables)
	Stores the current row ID of "table" in the specified field of "tmp_table". More...

static bool	PositionScanOnRow (TABLE updated_table, TABLE table, TABLE *tmp_table, int field_num)
	Position the scan of "table" using the row ID stored in the specified field of "tmp_table". More...

table_map	GetImmediateUpdateTable (const JOIN *join, bool single_target)
	Find out which of the target tables can be updated immediately while scanning. More...

bool	FinalizeOptimizationForUpdate (JOIN *join)
	Makes the TABLE and handler objects ready for being used in an UPDATE statement. More...

unique_ptr_destroy_only< RowIterator >	CreateUpdateRowsIterator (THD thd, MEM_ROOT mem_root, JOIN *join, unique_ptr_destroy_only< RowIterator > source)
	Creates an UpdateRowsIterator which updates the rows returned by the given "source" iterator. More...

Function Documentation

◆ AddRowIdAsTempTableField()

static bool AddRowIdAsTempTableField	(	THD *	thd,
		TABLE *	table,
		mem_root_deque< Item * > *	fields
	)

static

Adds a field for storing row IDs from "table" to "fields".

◆ check_constant_expressions()

static bool check_constant_expressions ( const mem_root_deque< Item * > & values )

static

Check if all expressions in list are constant expressions.

Parameters

[in] values List of expressions

Return values

true	Only constant expressions
false	At least one non-constant expression

◆ CollectColumnsReferencedInJoinConditions()

static void CollectColumnsReferencedInJoinConditions	(	const JOIN *	join,
		const Table_ref *	table_ref
	)

static

◆ compare_records()

bool compare_records ( const TABLE * table )

Compares the input and output record buffers of the table to see if a row has changed.

The algorithm iterates over updated columns and if they are nullable compares NULL bits in the buffer before comparing actual data. Special care must be taken to compare only the relevant NULL bits and mask out all others as they may be undefined. The storage engine will not and should not touch them.

Parameters

table The table to evaluate.

Returns: true if row has changed.; false otherwise.

◆ CreateUpdateRowsIterator()

unique_ptr_destroy_only< RowIterator > CreateUpdateRowsIterator	(	THD *	thd,
		MEM_ROOT *	mem_root,
		JOIN *	join,
		unique_ptr_destroy_only< RowIterator >	source
	)

Creates an UpdateRowsIterator which updates the rows returned by the given "source" iterator.

◆ FinalizeOptimizationForUpdate()

bool FinalizeOptimizationForUpdate ( JOIN * join )

Makes the TABLE and handler objects ready for being used in an UPDATE statement.

Called at the beginning of each execution.

Parameters

join	The top-level JOIN object of the UPDATE operation.

Returns: true on error.

◆ get_table_map()

static table_map get_table_map ( const mem_root_deque< Item * > & items )

static

◆ GetImmediateUpdateTable()

table_map GetImmediateUpdateTable	(	const JOIN *	join,
		bool	single_target
	)

Find out which of the target tables can be updated immediately while scanning.

This is used by the old optimizer after the plan has been created. The hypergraph optimizer does not use this function, as it makes the decision about immediate update during planning, not after planning.

Parameters

join	The top-level JOIN object of the UPDATE statement.
single_target	True if the UPDATE statement has exactly one target table.

Returns: Map of tables to update while scanning.

◆ GetOutermostTable()

static TABLE * GetOutermostTable ( const JOIN * join )

static

Returns the outermost (leftmost) table of a join.

◆ has_json_columns()

static bool has_json_columns ( const mem_root_deque< Item * > & items )

static

Check if a list of Items contains an Item whose type is JSON.

◆ PositionScanOnRow()

static bool PositionScanOnRow	(	TABLE *	updated_table,
		TABLE *	table,
		TABLE *	tmp_table,
		int	field_num
	)

static

Position the scan of "table" using the row ID stored in the specified field of "tmp_table".

Parameters

updated_table	The table that is being updated.
table	The table to position on a given row.
tmp_table	The temporary table that holds the row ID.
field_num	The field of tmp_table that holds the row ID.

Returns: True on error.

◆ prepare_partial_update()

static bool prepare_partial_update	(	Opt_trace_context *	trace,
		const mem_root_deque< Item * > &	fields,
		const mem_root_deque< Item * > &	values
	)

static

Mark the columns that can possibly be updated in-place using partial update.

Only JSON columns can be updated in-place, and only if all the updates of the column are on the form

json_col = JSON_SET(json_col, ...)

json_col = JSON_REPLACE(json_col, ...)

json_col = JSON_REMOVE(json_col, ...)

Even though a column is marked for partial update, it is not necessarily updated as a partial update during execution. It depends on the actual data in the column if it is possible to do it as a partial update. Also, for multi-table updates, it is only possible to perform partial updates in the first table of the join operation, and it is not determined until later (in Query_result_update::optimize()) which table it is.

Parameters

trace	the optimizer trace context
fields	the fields that are updated by the update statement
values	the values they are updated to

Returns: false on success, true on error

◆ records_are_comparable()

bool records_are_comparable ( const TABLE * table )

True if the table's input and output record buffers are comparable using compare_records(TABLE*).

◆ safe_update_on_fly()

static bool safe_update_on_fly	(	const QEP_TAB *	join_tab,
		const Table_ref *	table_ref,
		Table_ref *	all_tables
	)

static

Check if table is safe to update on the fly.

Parameters

join_tab	Table (always the first one in the JOIN plan)
table_ref	Table reference for 'join_tab'
all_tables	List of tables (updated or not)

We can update the first table in join on the fly if we know that:

a row in this table will never be read twice (that depends, among other things, on the access method), and
updating this row won't influence the selection of rows in next tables.

This function gets information about fields to be updated from the TABLE::write_set bitmap. And it gets information about which fields influence the selection of rows in next tables, from the TABLE::tmp_set bitmap.

Returns: true if it is safe to update on the fly.

◆ should_switch_to_multi_table_if_subqueries()

bool should_switch_to_multi_table_if_subqueries	(	const THD *	thd,
		const Query_block *	select,
		const Table_ref *	table_list
	)

Decides if a single-table UPDATE/DELETE statement should switch to the multi-table code path, if there are subqueries which might benefit from semijoin or subquery materialization, and if no feature specific to the single-table path are used.

Parameters

thd	Thread handler
select	Query block
table_list	Table to modify

Returns: true if we should switch

◆ StoreRowId()

static void StoreRowId	(	TABLE *	table,
		TABLE *	tmp_table,
		int	field_num,
		table_map	hash_join_tables
	)

static

Stores the current row ID of "table" in the specified field of "tmp_table".

Parameters

table	The table to get a row ID from.
tmp_table	The temporary table in which to store the row ID.
field_num	The field of tmp_table in which to store the row ID.
hash_join_tables	A map of all tables that are part of a hash join.

◆ unsafe_key_update()

static bool unsafe_key_update	(	Table_ref *	leaves,
		table_map	tables_for_update
	)

static

If one row is updated through two different aliases and the first update physically moves the row, the second update will error because the row is no longer located where expected.

This function checks if the multiple-table update is about to do that and if so returns with an error.

The following update operations physically moves rows: 1) Update of a column in a clustered primary key 2) Update of a column used to calculate which partition the row belongs to

This function returns with an error if both of the following are true:

a) A table in the multiple-table update statement is updated through multiple aliases (including views) b) At least one of the updates on the table from a) may physically moves the row. Note: Updating a column used to calculate which partition a row belongs to does not necessarily mean that the row is moved. The new value may or may not belong to the same partition.

Parameters

leaves	First leaf table
tables_for_update	Map of tables that are updated

Returns: true if the update is unsafe, in which case an error message is also set, false otherwise.

Functions

Function Documentation

◆ AddRowIdAsTempTableField()

◆ check_constant_expressions()

◆ CollectColumnsReferencedInJoinConditions()

◆ compare_records()

◆ CreateUpdateRowsIterator()

◆ FinalizeOptimizationForUpdate()

◆ get_table_map()

◆ GetImmediateUpdateTable()

◆ GetOutermostTable()

◆ has_json_columns()

◆ PositionScanOnRow()

◆ prepare_partial_update()

◆ records_are_comparable()

◆ safe_update_on_fly()

◆ should_switch_to_multi_table_if_subqueries()

◆ StoreRowId()

◆ unsafe_key_update()