MySQL 8.0.31
Source Code Documentation
sql_update.h
Go to the documentation of this file.
1/* Copyright (c) 2006, 2022, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is also distributed with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have included with MySQL.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License, version 2.0, for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
22
23#ifndef SQL_UPDATE_INCLUDED
24#define SQL_UPDATE_INCLUDED
25
26#include <sys/types.h>
27
28#include "mem_root_deque.h"
29#include "my_alloc.h"
30#include "my_sqlcommand.h"
31#include "my_table_map.h"
32#include "sql/query_result.h" // Query_result_interceptor
33#include "sql/sql_cmd_dml.h" // Sql_cmd_dml
34#include "sql/sql_list.h"
35#include "sql/thr_malloc.h"
36
37class COPY_INFO;
38class Copy_field;
39class Item;
40class JOIN;
41class Query_block;
43class RowIterator;
45class THD;
47struct TABLE;
48struct TABLE_LIST;
49
51bool compare_records(const TABLE *table);
53 const Query_block *select,
54 const TABLE_LIST *table_list);
55
57 /// Number of tables being updated
59 /// Pointer to list of updated tables, linked via 'next_local'
61 /// Array of references to temporary tables used to store cached updates
62 TABLE **tmp_tables{nullptr};
63 /// Array of parameter structs for creation of temporary tables
65 /// The first table in the join operation
66 TABLE *main_table{nullptr};
67 /**
68 In a multi-table update, this is equal to the first table in the join
69 operation (#main_table) if that table can be updated on the fly while
70 scanning it. It is `nullptr` otherwise.
71
72 @see safe_update_on_fly
73 */
75 /// List of pointers to fields to update, in order from statement
77 /// List of pointers to values to update with, in order from statement
79 /// The fields list decomposed into separate lists per table
81 /// The values list decomposed into separate lists per table
83 /**
84 List of tables referenced in the CHECK OPTION condition of
85 the updated view excluding the updated table.
86 */
88 /// ???
90
91 /**
92 Array of update operations, arranged per _updated_ table. For each
93 _updated_ table in the multiple table update statement, a COPY_INFO
94 pointer is present at the table's position in this array.
95
96 The array is allocated and populated during Query_result_update::prepare().
97 The position that each table is assigned is also given here and is stored
98 in the member TABLE::pos_in_table_list::shared. However, this is a publicly
99 available field, so nothing can be trusted about its integrity.
100
101 This member is NULL when the Query_result_update is created.
102
103 @see Query_result_update::prepare
104 */
106
107 public:
109 mem_root_deque<Item *> *value_list)
110 : Query_result_interceptor(), fields(field_list), values(value_list) {}
111 bool need_explain_interceptor() const override { return true; }
112 bool prepare(THD *thd, const mem_root_deque<Item *> &list,
113 Query_expression *u) override;
114 bool optimize();
115 bool start_execution(THD *thd) override;
116 bool send_data(THD *thd, const mem_root_deque<Item *> &items) override;
117 bool do_updates(THD *thd);
118 bool send_eof(THD *thd) override;
119 void cleanup() override;
121 THD *thd, MEM_ROOT *mem_root,
123};
124
125class Sql_cmd_update final : public Sql_cmd_dml {
126 public:
127 Sql_cmd_update(bool multitable_arg, mem_root_deque<Item *> *update_values)
128 : multitable(multitable_arg),
130 update_value_list(update_values) {}
131
134 }
135
136 bool is_single_table_plan() const override { return !multitable; }
137
138 protected:
139 bool precheck(THD *thd) override;
140 bool check_privileges(THD *thd) override;
141
142 bool prepare_inner(THD *thd) override;
143
144 bool execute_inner(THD *thd) override;
145
146 private:
147 bool update_single_table(THD *thd);
148
150
151 /// Bitmap of all tables which are to be updated
153
154 bool accept(THD *thd, Select_lex_visitor *visitor) override;
155
156 /// Convert list of fields to update to base table fields
158
159 public:
160 /// The original list of fields to update, used for privilege checking
162 /// The values used to update fields
164};
165
166/// Find out which of the target tables can be updated immediately while
167/// scanning. This is used by the old optimizer *after* the plan has been
168/// created. The hypergraph optimizer does not use this function, as it makes
169/// the decision about immediate update *during* planning, not after planning.
170///
171/// @param join The top-level JOIN object of the UPDATE statement.
172/// @param single_target True if the UPDATE statement has exactly
173/// one target table.
174/// @return Map of tables to update while scanning.
175table_map GetImmediateUpdateTable(const JOIN *join, bool single_target);
176
177/// Makes the TABLE and handler objects ready for being used in an UPDATE
178/// statement. Called at the beginning of each execution.
179///
180/// @param join The top-level JOIN object of the UPDATE operation.
181/// @return true on error.
183
184/// Creates an UpdateRowsIterator which updates the rows returned by the given
185/// "source" iterator.
187 THD *thd, MEM_ROOT *mem_root, JOIN *join,
189
190#endif /* SQL_UPDATE_INCLUDED */
This class encapsulates a data change operation.
Definition: sql_data_change.h:73
Definition: field.h:4572
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:802
Definition: sql_optimizer.h:125
Definition: sql_list.h:433
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1159
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:622
Definition: query_result.h:173
Definition: sql_update.h:56
Copy_field * copy_field
???
Definition: sql_update.h:89
bool do_updates(THD *thd)
const mem_root_deque< Item * > * values
List of pointers to values to update with, in order from statement.
Definition: sql_update.h:78
TABLE * table_to_update
In a multi-table update, this is equal to the first table in the join operation (main_table) if that ...
Definition: sql_update.h:74
bool need_explain_interceptor() const override
Definition: sql_update.h:111
mem_root_deque< Item * > ** fields_for_table
The fields list decomposed into separate lists per table.
Definition: sql_update.h:80
Temp_table_param * tmp_table_param
Array of parameter structs for creation of temporary tables.
Definition: sql_update.h:64
unique_ptr_destroy_only< RowIterator > create_iterator(THD *thd, MEM_ROOT *mem_root, unique_ptr_destroy_only< RowIterator > source)
Definition: sql_update.cc:3062
bool prepare(THD *thd, const mem_root_deque< Item * > &list, Query_expression *u) override
Perform preparation specific to the query expression or DML statement.
Definition: sql_update.cc:1821
TABLE ** tmp_tables
Array of references to temporary tables used to store cached updates.
Definition: sql_update.h:62
bool start_execution(THD *thd) override
Prepare for execution of the query expression or DML statement.
Definition: sql_update.cc:2372
List< TABLE > unupdated_check_opt_tables
List of tables referenced in the CHECK OPTION condition of the updated view excluding the updated tab...
Definition: sql_update.h:87
bool send_data(THD *thd, const mem_root_deque< Item * > &items) override
Definition: sql_update.cc:2406
COPY_INFO ** update_operations
Array of update operations, arranged per updated table.
Definition: sql_update.h:105
const mem_root_deque< Item * > * fields
List of pointers to fields to update, in order from statement.
Definition: sql_update.h:76
bool send_eof(THD *thd) override
Definition: sql_update.cc:2934
void cleanup() override
Cleanup after this execution.
Definition: sql_update.cc:2378
TABLE_LIST * update_tables
Pointer to list of updated tables, linked via 'next_local'.
Definition: sql_update.h:60
TABLE * main_table
The first table in the join operation.
Definition: sql_update.h:66
bool optimize()
Set up data structures for multi-table UPDATE.
Definition: sql_update.cc:2178
uint update_table_count
Number of tables being updated.
Definition: sql_update.h:58
mem_root_deque< Item * > ** values_for_table
The values list decomposed into separate lists per table.
Definition: sql_update.h:82
Query_result_update(mem_root_deque< Item * > *field_list, mem_root_deque< Item * > *value_list)
Definition: sql_update.h:108
A context for reading through a single table using a chosen access method: index read,...
Definition: row_iterator.h:81
Abstract base class for traversing the Query_block tree.
Definition: select_lex_visitor.h:39
Definition: sql_cmd_dml.h:34
Definition: sql_update.h:125
bool precheck(THD *thd) override
Perform a precheck of table privileges for the specific operation.
Definition: sql_update.cc:127
enum_sql_command sql_command_code() const override
Return the command code for this statement.
Definition: sql_update.h:132
bool prepare_inner(THD *thd) override
Perform the command-specific parts of DML command preparation, to be called from prepare()
Definition: sql_update.cc:1466
Sql_cmd_update(bool multitable_arg, mem_root_deque< Item * > *update_values)
Definition: sql_update.h:127
bool check_privileges(THD *thd) override
Check privileges on a prepared statement, called at start of execution of the statement.
Definition: sql_update.cc:193
mem_root_deque< Item * > * update_value_list
The values used to update fields.
Definition: sql_update.h:163
table_map tables_for_update
Bitmap of all tables which are to be updated.
Definition: sql_update.h:152
bool multitable
Definition: sql_update.h:149
bool execute_inner(THD *thd) override
The inner parts of query optimization and execution.
Definition: sql_update.cc:1798
mem_root_deque< Item * > original_fields
The original list of fields to update, used for privilege checking.
Definition: sql_update.h:161
bool update_single_table(THD *thd)
Perform an update to a set of rows in a single table.
Definition: sql_update.cc:365
bool is_single_table_plan() const override
Definition: sql_update.h:136
bool make_base_table_fields(THD *thd, mem_root_deque< Item * > *items)
Convert list of fields to update to base table fields.
Definition: sql_update.cc:309
bool accept(THD *thd, Select_lex_visitor *visitor) override
Definition: sql_update.cc:2955
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:922
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:94
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:109
static MEM_ROOT mem_root
Definition: client_plugin.cc:109
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
std::unique_ptr< T, Destroy_only< T > > unique_ptr_destroy_only
std::unique_ptr, but only destroying.
Definition: my_alloc.h:488
enum_sql_command
Definition: my_sqlcommand.h:45
@ SQLCOM_UPDATE
Definition: my_sqlcommand.h:50
@ SQLCOM_UPDATE_MULTI
Definition: my_sqlcommand.h:121
uint64_t table_map
Definition: my_table_map.h:29
thread_local MEM_ROOT ** THR_MALLOC
Definition: mysqld.cc:1549
std::string join(Container cont, const std::string &delim)
join elements of an container into a string separated by a delimiter.
Definition: string.h:150
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2859
repeated Source source
Definition: replication_asynchronous_connection_failover.proto:41
bool records_are_comparable(const TABLE *table)
True if the table's input and output record buffers are comparable using compare_records(TABLE*).
Definition: sql_update.cc:235
table_map GetImmediateUpdateTable(const JOIN *join, bool single_target)
Find out which of the target tables can be updated immediately while scanning.
Definition: sql_update.cc:2987
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.
Definition: sql_update.cc:3055
bool FinalizeOptimizationForUpdate(JOIN *join)
Makes the TABLE and handler objects ready for being used in an UPDATE statement.
Definition: sql_update.cc:3029
bool compare_records(const TABLE *table)
Compares the input and output record buffers of the table to see if a row has changed.
Definition: sql_update.cc:253
bool should_switch_to_multi_table_if_subqueries(const THD *thd, const Query_block *select, const TABLE_LIST *table_list)
Decides if a single-table UPDATE/DELETE statement should switch to the multi-table code path,...
Definition: sql_update.cc:1433
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:82
Definition: table.h:2756
TABLE * table
Definition: table.h:3530
Definition: table.h:1396
unsigned int uint
Definition: uca-dump.cc:29