MySQL 8.4.3
Source Code Documentation
sql_base.h
Go to the documentation of this file.
1/* Copyright (c) 2010, 2024, 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 designed to work 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 either included with
13 the program or referenced in the documentation.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
23
24#ifndef SQL_BASE_INCLUDED
25#define SQL_BASE_INCLUDED
26
27#include <stddef.h>
28#include <sys/types.h>
29#include <memory>
30#include <string>
31
32#include "lex_string.h"
33#include "map_helpers.h"
34#include "mem_root_deque.h"
35#include "my_base.h" // ha_extra_function
36#include "my_inttypes.h"
38#include "prealloced_array.h" // Prealloced_array
39#include "sql/auth/auth_acls.h" // Access_bitmask
40#include "sql/locked_tables_list.h" // enum_locked_tables_mode
41#include "sql/mdl.h" // MDL_savepoint
42#include "sql/sql_array.h" // Bounds_checked_array
43#include "sql/sql_const.h" // enum_resolution_type
44#include "sql/trigger_def.h" // enum_trigger_event_type
45#include "thr_lock.h" // thr_lock_type
46
47class COPY_INFO;
48class Field;
49class Item;
50class Item_ident;
55class Query_block;
57class THD;
58class sp_head;
59struct LEX;
60struct MY_BITMAP;
62struct OPEN_TABLE_LIST;
63struct TABLE;
64class Table_ref;
65struct TABLE_SHARE;
66struct handlerton;
67template <class T>
68class List;
69template <class T>
70class List_iterator;
71template <class T>
72class Mem_root_array;
73
75namespace dd {
76class Table;
77} // namespace dd
78
79#define TEMP_PREFIX "MY"
80
81/* Defines for use with openfrm, openprt and openfrd */
82
83#define READ_ALL 1 /* openfrm: Read all parameters */
84#define EXTRA_RECORD 8 /* Reservera plats f|r extra record */
85#define DELAYED_OPEN 4096 /* Open table later */
86/**
87 If set, open_table_from_share() will skip calling get_new_handler() to
88 create a new handler object for the table. Designed to be used when
89 opening a table from inside storage engines.
90*/
91#define SKIP_NEW_HANDLER 32768
92
99};
100
108
110bool table_def_init(void);
111void table_def_free(void);
112void table_def_start_shutdown(void);
114uint cached_table_definitions(void);
115size_t get_table_def_key(const Table_ref *table_list, const char **key);
116TABLE_SHARE *get_table_share(THD *thd, const char *db, const char *table_name,
117 const char *key, size_t key_length, bool open_view,
118 bool open_secondary = false);
120
122 uint lock_flags);
123
124/* mysql_lock_tables() and open_table() flags bits */
125#define MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK 0x0001
126#define MYSQL_OPEN_IGNORE_FLUSH 0x0002
127/* MYSQL_OPEN_TEMPORARY_ONLY (0x0004) is not used anymore. */
128#define MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY 0x0008
129#define MYSQL_LOCK_LOG_TABLE 0x0010
130/**
131 Do not try to acquire a metadata lock on the table: we
132 already have one.
133*/
134#define MYSQL_OPEN_HAS_MDL_LOCK 0x0020
135/**
136 If in locked tables mode, ignore the locked tables and get
137 a new instance of the table.
138*/
139#define MYSQL_OPEN_GET_NEW_TABLE 0x0040
140/* 0x0080 used to be MYSQL_OPEN_SKIP_TEMPORARY */
141/** Fail instead of waiting when conficting metadata lock is discovered. */
142#define MYSQL_OPEN_FAIL_ON_MDL_CONFLICT 0x0100
143/** Open tables using MDL_SHARED lock instead of one specified in parser. */
144#define MYSQL_OPEN_FORCE_SHARED_MDL 0x0200
145/**
146 Open tables using MDL_SHARED_HIGH_PRIO lock instead of one specified
147 in parser.
148*/
149#define MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL 0x0400
150/**
151 When opening or locking the table, use the maximum timeout
152 (LONG_TIMEOUT = 1 year) rather than the user-supplied timeout value.
153*/
154#define MYSQL_LOCK_IGNORE_TIMEOUT 0x0800
155/**
156 When acquiring "strong" (SNW, SNRW, X) metadata locks on tables to
157 be open do not acquire global, tablespace-scope and schema-scope IX locks.
158*/
159#define MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK 0x1000
160/**
161 When opening or locking a replication table through an internal
162 operation rather than explicitly through an user thread.
163*/
164#define MYSQL_LOCK_RPL_INFO_TABLE 0x2000
165/**
166 Only check THD::killed if waits happen (e.g. wait on MDL, wait on
167 table flush, wait on thr_lock.c locks) while opening and locking table.
168*/
169#define MYSQL_OPEN_IGNORE_KILLED 0x4000
170/**
171 For new TABLE instances constructed do not open table in the storage
172 engine. Existing TABLE instances for which there is a handler object
173 which represents table open in storage engines can still be used.
174*/
175#define MYSQL_OPEN_NO_NEW_TABLE_IN_SE 0x8000
176/** Open a shadow copy of a table from a secondary storage engine. */
177#define MYSQL_OPEN_SECONDARY_ENGINE 0x10000
178
179/** Please refer to the internals manual. */
180#define MYSQL_OPEN_REOPEN \
181 (MYSQL_OPEN_IGNORE_FLUSH | MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK | \
182 MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY | MYSQL_LOCK_IGNORE_TIMEOUT | \
183 MYSQL_OPEN_IGNORE_KILLED | MYSQL_OPEN_GET_NEW_TABLE | \
184 MYSQL_OPEN_HAS_MDL_LOCK)
185
186bool open_table(THD *thd, Table_ref *table_list, Open_table_context *ot_ctx);
187
188TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
189 const char *table_name,
190 bool add_to_temporary_tables_list,
191 bool open_in_engine, const dd::Table &table_def);
192TABLE *find_locked_table(TABLE *list, const char *db, const char *table_name);
194 Query_tables_list *prelocking_ctx,
195 Table_ref *table_list,
196 bool routine_modifies_data);
197
198bool mysql_rm_tmp_tables(void);
199bool rm_temporary_table(THD *thd, handlerton *base, const char *path,
200 const dd::Table *table_def);
201void close_tables_for_reopen(THD *thd, Table_ref **tables,
202 const MDL_savepoint &start_of_statement_svp);
203TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name);
204TABLE *find_temporary_table(THD *thd, const Table_ref *tl);
205void close_thread_tables(THD *thd);
207 THD *thd, COPY_INFO *optype_info, const mem_root_deque<Item *> &fields,
208 const mem_root_deque<Item *> &values, TABLE *table,
209 enum enum_trigger_event_type event, int num_fields,
210 bool raise_autoinc_has_expl_non_null_val, bool *is_row_changed);
212 const mem_root_deque<Item *> &values,
213 TABLE *table,
215 int num_fields);
216bool resolve_var_assignments(THD *thd, LEX *lex);
217bool insert_fields(THD *thd, Query_block *query_block, const char *db_name,
218 const char *table_name, mem_root_deque<Item *> *fields,
219 mem_root_deque<Item *>::iterator *it, bool any_privileges);
220bool setup_fields(THD *thd, Access_bitmask want_privilege, bool allow_sum_func,
221 bool split_sum_funcs, bool column_update,
222 const mem_root_deque<Item *> *typed_items,
224 Ref_item_array ref_item_array);
225bool fill_record(THD *thd, TABLE *table, const mem_root_deque<Item *> &fields,
226 const mem_root_deque<Item *> &values, MY_BITMAP *bitmap,
227 MY_BITMAP *insert_into_fields_bitmap,
228 bool raise_autoinc_has_expl_non_null_val);
229bool fill_record(THD *thd, TABLE *table, Field **field,
230 const mem_root_deque<Item *> &values, MY_BITMAP *bitmap,
231 MY_BITMAP *insert_into_fields_bitmap,
232 bool raise_autoinc_has_expl_non_null_val);
233
234bool check_record(THD *thd, Field **ptr);
235
236/**
237 Invoke check constraints defined on the table.
238
239 @param thd Thread handle.
240 @param table Instance of TABLE.
241
242 @retval false If all enforced check constraints are satisfied.
243 @retval true Otherwise. THD::is_error() may be "true" in this case.
244*/
246
247Field *find_field_in_tables(THD *thd, Item_ident *item, Table_ref *first_table,
248 Table_ref *last_table, Item **ref,
250 Access_bitmask want_privilege,
251 bool register_tree_change);
252Field *find_field_in_table_ref(THD *thd, Table_ref *table_list,
253 const char *name, size_t length,
254 const char *item_name, const char *db_name,
255 const char *table_name, Item **ref,
256 Access_bitmask want_privilege, bool allow_rowid,
257 uint *cached_field_index_ptr,
258 bool register_tree_change,
259 Table_ref **actual_table);
260Field *find_field_in_table(TABLE *table, const char *name, bool allow_rowid,
261 uint *cached_field_index_ptr);
263bool find_item_in_list(THD *thd, Item *item, mem_root_deque<Item *> *items,
264 Item ***found, uint *counter,
265 enum_resolution_type *resolution);
267 mem_root_deque<Table_ref *> *from_clause,
268 Name_resolution_context *context);
270 enum ha_extra_function function);
271
272void update_non_unique_table_error(Table_ref *update, const char *operation,
273 Table_ref *duplicate);
274int setup_ftfuncs(const THD *thd, Query_block *select);
275bool init_ftfuncs(THD *thd, Query_block *select);
276int run_before_dml_hook(THD *thd);
277bool get_and_lock_tablespace_names(THD *thd, Table_ref *tables_start,
278 Table_ref *tables_end,
279 ulong lock_wait_timeout, uint flags);
281 THD *thd, Table_ref *table_list, Table_ref *table_list_end,
282 ulong lock_wait_timeout, uint flags,
283 Prealloced_array<MDL_request *, 1> *schema_reqs = nullptr);
284bool open_tables(THD *thd, Table_ref **tables, uint *counter, uint flags,
285 Prelocking_strategy *prelocking_strategy);
286/* open_and_lock_tables */
287bool open_and_lock_tables(THD *thd, Table_ref *tables, uint flags,
288 Prelocking_strategy *prelocking_strategy);
289/* simple open_and_lock_tables for single table */
291 thr_lock_type lock_type, uint flags,
292 Prelocking_strategy *prelocking_strategy);
293bool open_tables_for_query(THD *thd, Table_ref *tables, uint flags);
294bool lock_tables(THD *thd, Table_ref *tables, uint counter, uint flags);
295bool lock_dictionary_tables(THD *thd, Table_ref *tables, uint count,
296 uint flags);
299void close_thread_table(THD *thd, TABLE **table_ptr);
300bool close_temporary_tables(THD *thd);
301Table_ref *unique_table(const Table_ref *table, Table_ref *table_list,
302 bool check_alias);
303void drop_temporary_table(THD *thd, Table_ref *table_list);
305 bool delete_table);
306void close_temporary(THD *thd, TABLE *table, bool free_share,
307 bool delete_table);
308bool rename_temporary_table(THD *thd, TABLE *table, const char *new_db,
309 const char *table_name);
310bool open_temporary_tables(THD *thd, Table_ref *tl_list);
311bool open_temporary_table(THD *thd, Table_ref *tl);
312
313/* Functions to work with system tables. */
314bool open_trans_system_tables_for_read(THD *thd, Table_ref *table_list);
316void close_mysql_tables(THD *thd);
317TABLE *open_log_table(THD *thd, Table_ref *one_table,
320
321bool close_cached_tables(THD *thd, Table_ref *tables, bool wait_for_refresh,
322 ulong timeout);
323
324/**
325 Close all open instances of the table but keep the MDL lock.
326
327 Works both under LOCK TABLES and in the normal mode.
328 Removes all closed instances of the table from the table cache.
329
330 @param thd Thread context.
331 @param share Table share, but is just a handy way to
332 access the table cache key.
333 @param remove_from_locked_tables
334 True if the table is being dropped.
335 In that case the documented behaviour is to
336 implicitly remove the table from LOCK TABLES list.
337 @param skip_table TABLE instance that should be kept open.
338
339 @pre Must be called with an X MDL lock on the table.
340*/
342 bool remove_from_locked_tables,
343 TABLE *skip_table);
344
345/**
346 Close all open instances of the table but keep the MDL lock.
347
348 Works both under LOCK TABLES and in the normal mode.
349 Removes all closed instances of the table from the table cache.
350
351 @param thd Thread context.
352 @param db Database name.
353 @param table_name Table name.
354 @param remove_from_locked_tables
355 True if the table is being dropped.
356 In that case the documented behaviour is to
357 implicitly remove the table from LOCK TABLES list.
358
359 @pre Must be called with an X MDL lock on the table.
360*/
361void close_all_tables_for_name(THD *thd, const char *db, const char *table_name,
362 bool remove_from_locked_tables);
363
364OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild);
365void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
366 const char *db, const char *table_name, bool has_lock);
368TABLE *find_table_for_mdl_upgrade(THD *thd, const char *db,
369 const char *table_name, bool no_error);
371
372extern Field *not_found_field;
373extern Field *view_ref_found;
374
376 void operator()(TABLE_SHARE *share) const;
377};
378extern malloc_unordered_map<std::string,
379 std::unique_ptr<TABLE_SHARE, Table_share_deleter>>
381
383 const char *table_name);
384
385/**
386 An abstract class for a strategy specifying how the prelocking
387 algorithm should extend the prelocking set while processing
388 already existing elements in the set.
389*/
390
392 public:
393 virtual ~Prelocking_strategy() = default;
394
395 virtual bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
397 bool *need_prelocking) = 0;
398 virtual bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
399 Table_ref *table_list, bool *need_prelocking) = 0;
400 virtual bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
401 Table_ref *table_list, bool *need_prelocking) = 0;
402};
403
404/**
405 A Strategy for prelocking algorithm suitable for DML statements.
406
407 Ensures that all tables used by all statement's SF/SP/triggers and
408 required for foreign key checks are prelocked and SF/SPs used are
409 cached.
410*/
411
413 public:
414 bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
416 bool *need_prelocking) override;
417 bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
418 Table_ref *table_list, bool *need_prelocking) override;
419 bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
420 Table_ref *table_list, bool *need_prelocking) override;
421};
422
423/**
424 A strategy for prelocking algorithm to be used for LOCK TABLES
425 statement.
426*/
427
429 bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
430 Table_ref *table_list, bool *need_prelocking) override;
431};
432
433/**
434 Strategy for prelocking algorithm to be used for ALTER TABLE statements.
435
436 Unlike DML or LOCK TABLES strategy, it doesn't
437 prelock triggers, views or stored routines, since they are not
438 used during ALTER.
439*/
440
442 public:
443 bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
445 bool *need_prelocking) override;
446 bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
447 Table_ref *table_list, bool *need_prelocking) override;
448 bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
449 Table_ref *table_list, bool *need_prelocking) override;
450};
451
452inline bool open_tables(THD *thd, Table_ref **tables, uint *counter,
453 uint flags) {
454 DML_prelocking_strategy prelocking_strategy;
455
456 return open_tables(thd, tables, counter, flags, &prelocking_strategy);
457}
458
460 thr_lock_type lock_type, uint flags) {
461 DML_prelocking_strategy prelocking_strategy;
462
463 return open_n_lock_single_table(thd, table_l, lock_type, flags,
464 &prelocking_strategy);
465}
466
467// open_and_lock_tables with default prelocking strategy
468inline bool open_and_lock_tables(THD *thd, Table_ref *tables, uint flags) {
469 DML_prelocking_strategy prelocking_strategy;
470
471 return open_and_lock_tables(thd, tables, flags, &prelocking_strategy);
472}
473
474/**
475 Get an existing table definition from the table definition cache.
476
477 Search the table definition cache for a share with the given key.
478 If the share exists or if it is in the process of being opened
479 by another thread (m_open_in_progress flag is true) return share.
480 Do not wait for share opening to finish.
481
482 @param db database name.
483 @param table_name table name.
484
485 @retval nulltpr a share for the table does not exist in the cache
486 @retval != nulltpr pointer to existing share in the cache
487*/
488
489TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);
490
491/**
492 A context of open_tables() function, used to recover
493 from a failed open_table() or open_routine() attempt.
494*/
495
497 public:
505 };
506 Open_table_context(THD *thd, uint flags);
507
511
513
514 /**
515 When doing a back-off, we close all tables acquired by this
516 statement. Return an MDL savepoint taken at the beginning of
517 the statement, so that we can rollback to it before waiting on
518 locks.
519 */
522 }
523
524 inline ulong get_timeout() const { return m_timeout; }
525
526 uint get_flags() const { return m_flags; }
527
528 /**
529 Set flag indicating that we have already acquired metadata lock
530 protecting this statement against GRL while opening tables.
531 */
533
536 }
537
538 bool can_back_off() const { return !m_has_locks; }
539
540 private:
541 /* THD for which tables are opened. */
543 /**
544 For OT_DISCOVER, OT_REPAIR and OT_FIX_ROW_TYPE actions, the table list
545 element for the table which definition should be re-discovered/updated
546 or which should be repaired.
547 */
550 /**
551 Lock timeout in seconds. Initialized to LONG_TIMEOUT when opening system
552 tables or to the "lock_wait_timeout" system variable for regular tables.
553 */
555 /* open_table() flags. */
557 /** Back off action. */
559 /**
560 Whether we had any locks when this context was created.
561 If we did, they are from the previous statement of a transaction,
562 and we can't safely do back-off (and release them).
563 */
565 /**
566 Indicates that in the process of opening tables we have acquired
567 protection against global read lock.
568 */
570};
571
572/**
573 Check if given Table_ref is a acl table and is being read and not
574 in LOCK TABLE mode.
575
576 @param tl Table_ref pointing to the table.
577 @param ltm THD->locked_tables_mode enum.
578
579 @return true if acl table is being read, otherwise false.
580*/
582 enum enum_locked_tables_mode ltm);
583
584/**
585 Create a table cache/table definition cache key for a table in a
586 secondary storage engine.
587
588 The key is constructed by appending a single byte with the value 1
589 to the key generated by #create_table_def_key().
590
591 @param db_name the database name
592 @param table_name the table name
593 @return the key
594*/
595std::string create_table_def_key_secondary(const char *db_name,
596 const char *table_name);
597#endif /* SQL_BASE_INCLUDED */
uint32_t Access_bitmask
Definition: auth_acls.h:34
Strategy for prelocking algorithm to be used for ALTER TABLE statements.
Definition: sql_base.h:441
This class encapsulates a data change operation.
Definition: sql_data_change.h:74
A Strategy for prelocking algorithm suitable for DML statements.
Definition: sql_base.h:412
Definition: field.h:575
Definition: item.h:4082
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
Definition: sql_list.h:606
Definition: sql_list.h:467
A strategy for prelocking algorithm to be used for LOCK TABLES statement.
Definition: sql_base.h:428
Savepoint for MDL context.
Definition: mdl.h:1317
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
A context of open_tables() function, used to recover from a failed open_table() or open_routine() att...
Definition: sql_base.h:496
uint m_flags
Definition: sql_base.h:556
Table_ref * m_failed_table
For OT_DISCOVER, OT_REPAIR and OT_FIX_ROW_TYPE actions, the table list element for the table which de...
Definition: sql_base.h:548
void set_has_protection_against_grl()
Set flag indicating that we have already acquired metadata lock protecting this statement against GRL...
Definition: sql_base.h:532
enum enum_open_table_action m_action
Back off action.
Definition: sql_base.h:558
enum_open_table_action
Definition: sql_base.h:498
@ OT_FIX_ROW_TYPE
Definition: sql_base.h:504
@ OT_DISCOVER
Definition: sql_base.h:502
@ OT_BACKOFF_AND_RETRY
Definition: sql_base.h:500
@ OT_REOPEN_TABLES
Definition: sql_base.h:501
@ OT_NO_ACTION
Definition: sql_base.h:499
@ OT_REPAIR
Definition: sql_base.h:503
ulong get_timeout() const
Definition: sql_base.h:524
uint get_flags() const
Definition: sql_base.h:526
bool has_protection_against_grl() const
Definition: sql_base.h:534
ulong m_timeout
Lock timeout in seconds.
Definition: sql_base.h:554
THD * m_thd
Definition: sql_base.h:542
bool m_has_locks
Whether we had any locks when this context was created.
Definition: sql_base.h:564
bool can_back_off() const
Definition: sql_base.h:538
const MDL_savepoint & start_of_statement_svp() const
When doing a back-off, we close all tables acquired by this statement.
Definition: sql_base.h:520
bool can_recover_from_failed_open() const
Definition: sql_base.h:512
MDL_savepoint m_start_of_statement_svp
Definition: sql_base.h:549
bool m_has_protection_against_grl
Indicates that in the process of opening tables we have acquired protection against global read lock.
Definition: sql_base.h:569
Storage for backup of Open_tables_state.
Definition: sql_class.h:693
A typesafe replacement for DYNAMIC_ARRAY.
Definition: prealloced_array.h:71
An abstract class for a strategy specifying how the prelocking algorithm should extend the prelocking...
Definition: sql_base.h:391
virtual bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking)=0
virtual bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking)=0
virtual ~Prelocking_strategy()=default
virtual bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx, Sroutine_hash_entry *rt, sp_head *sp, bool *need_prelocking)=0
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1163
Definition: sql_lex.h:2597
Structure that represents element in the set of stored routines used by statement or routine.
Definition: sp.h:225
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Definition: table.h:2864
Definition: table.h:47
std::unordered_map, but with my_malloc, so that you can track the memory used using PSI memory keys.
Definition: map_helpers.h:157
Definition: mem_root_deque.h:288
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
sp_head represents one instance of a stored program.
Definition: sp_head.h:383
A table definition from the master.
Definition: rpl_utility.h:248
static bool report_error(THD *thd, int error_code, Sql_condition::enum_severity_level level, Args... args)
Definition: error_handler.cc:291
TABLE * find_locked_table(TABLE *list, const char *db, const char *table_name)
Find table in the list of open tables.
Definition: sql_base.cc:3597
bool fill_record(THD *thd, TABLE *table, const mem_root_deque< Item * > &fields, const mem_root_deque< Item * > &values, MY_BITMAP *bitmap, MY_BITMAP *insert_into_fields_bitmap, bool raise_autoinc_has_expl_non_null_val)
Fill fields with given items.
Definition: sql_base.cc:9696
void free_io_cache(TABLE *entry)
Definition: sql_base.cc:1211
bool request_backoff_action(enum_open_table_action action_arg, Table_ref *table)
Check if we can back-off and set back off action if we can.
Definition: sql_base.cc:4167
void assign_new_table_id(TABLE_SHARE *share)
Definition: sql_base.cc:3692
void update_non_unique_table_error(Table_ref *update, const char *operation, Table_ref *duplicate)
Issue correct error message in case we found 2 duplicate tables which prevent some update operation.
Definition: sql_base.cc:2306
void release_table_share(TABLE_SHARE *share)
Mark that we are not using table share anymore.
Definition: sql_base.cc:1055
std::string create_table_def_key_secondary(const char *db_name, const char *table_name)
Create a table cache/table definition cache key for a table in a secondary storage engine.
Definition: sql_base.cc:416
bool rename_temporary_table(THD *thd, TABLE *table, const char *new_db, const char *table_name)
Definition: sql_base.cc:2507
TABLE_SHARE * get_cached_table_share(const char *db, const char *table_name)
Get an existing table definition from the table definition cache.
Definition: sql_base.cc:1089
TABLE * open_n_lock_single_table(THD *thd, Table_ref *table_l, thr_lock_type lock_type, uint flags, Prelocking_strategy *prelocking_strategy)
Open and lock one table.
Definition: sql_base.cc:6539
bool insert_fields(THD *thd, Query_block *query_block, const char *db_name, const char *table_name, mem_root_deque< Item * > *fields, mem_root_deque< Item * >::iterator *it, bool any_privileges)
Definition: sql_base.cc:9477
bool mysql_rm_tmp_tables(void)
Drop all temporary tables which have been left from previous server run.
Definition: sql_base.cc:10282
TABLE * open_log_table(THD *thd, Table_ref *one_table, Open_tables_backup *backup)
Open a log table.
Definition: sql_base.cc:10676
void close_temporary(THD *thd, TABLE *table, bool free_share, bool delete_table)
Definition: sql_base.cc:2477
void close_thread_tables(THD *thd)
Close all tables used by the current substatement, or all tables used by this thread if we are on the...
Definition: sql_base.cc:1629
malloc_unordered_map< std::string, std::unique_ptr< TABLE_SHARE, Table_share_deleter > > * table_def_cache
Definition: sql_base.cc:337
bool check_record(THD *thd, Field **ptr)
Check the NOT NULL constraint on all the fields of the current record.
Definition: sql_base.cc:9801
bool rm_temporary_table(THD *thd, handlerton *base, const char *path, const dd::Table *table_def)
Delete a temporary table.
Definition: sql_base.cc:7462
bool is_acl_table_in_non_LTM(const Table_ref *tl, enum enum_locked_tables_mode ltm)
Check if given Table_ref is a acl table and is being read and not in LOCK TABLE mode.
Definition: sql_base.cc:5766
bool init_ftfuncs(THD *thd, Query_block *select)
Definition: sql_base.cc:10510
TABLE_SHARE * get_table_share(THD *thd, const char *db, const char *table_name, const char *key, size_t key_length, bool open_view, bool open_secondary=false)
Get the TABLE_SHARE for a table.
Definition: sql_base.cc:748
bool find_item_in_list(THD *thd, Item *item, mem_root_deque< Item * > *items, Item ***found, uint *counter, enum_resolution_type *resolution)
Find Item in list of items (find_field_in_tables analog)
Definition: sql_base.cc:8299
OPEN_TABLE_LIST * list_open_tables(THD *thd, const char *db, const char *wild)
Definition: sql_base.cc:1116
TABLE * find_temporary_table(THD *thd, const char *db, const char *table_name)
Find temporary table specified by database and table names in the THD::temporary_tables list.
Definition: sql_base.cc:2350
TABLE * open_ltable(THD *thd, Table_ref *table_list, thr_lock_type update, uint lock_flags)
Definition: sql_base.cc:6589
size_t get_table_def_key(const Table_ref *table_list, const char **key)
Get table cache key for a table list element.
Definition: sql_base.cc:446
void close_temporary_table(THD *thd, TABLE *table, bool free_share, bool delete_table)
Definition: sql_base.cc:2438
Field * find_field_in_tables(THD *thd, Item_ident *item, Table_ref *first_table, Table_ref *last_table, Item **ref, find_item_error_report_type report_error, Access_bitmask want_privilege, bool register_tree_change)
Definition: sql_base.cc:8100
void operator()(TABLE_SHARE *share) const
Definition: sql_base.cc:467
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for DML statements should handle table list elements:
Definition: sql_base.cc:6281
bool setup_natural_join_row_types(THD *thd, mem_root_deque< Table_ref * > *from_clause, Name_resolution_context *context)
Definition: sql_base.cc:9039
Table_ref * unique_table(const Table_ref *table, Table_ref *table_list, bool check_alias)
Test that the subject table of INSERT/UPDATE/DELETE/CREATE or (in case of MyISAMMRG) one of its child...
Definition: sql_base.cc:2277
void close_all_tables_for_name(THD *thd, TABLE_SHARE *share, bool remove_from_locked_tables, TABLE *skip_table)
Close all open instances of the table but keep the MDL lock.
Definition: sql_base.cc:1560
void table_def_free(void)
Definition: sql_base.cc:519
Open_table_context(THD *thd, uint flags)
Open_table_context.
Definition: sql_base.cc:4147
void close_log_table(THD *thd, Open_tables_backup *backup)
Close a log table.
Definition: sql_base.cc:10707
void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type, const char *db, const char *table_name, bool has_lock)
Remove all or some (depending on parameter) instances of TABLE and TABLE_SHARE from the table definit...
Definition: sql_base.cc:10410
Field * not_found_field
Definition: sql_base.cc:7494
bool fill_record_n_invoke_before_triggers(THD *thd, COPY_INFO *optype_info, const mem_root_deque< Item * > &fields, const mem_root_deque< Item * > &values, TABLE *table, enum enum_trigger_event_type event, int num_fields, bool raise_autoinc_has_expl_non_null_val, bool *is_row_changed)
Fill fields in list with values from the list of items and invoke before triggers.
Definition: sql_base.cc:9977
void close_mysql_tables(THD *thd)
A helper function to close a mysql.
Definition: sql_base.cc:10658
void close_trans_system_tables(THD *thd)
Close transactional system tables, opened with open_trans_system_tables_for_read().
Definition: sql_base.cc:10633
bool open_temporary_table(THD *thd, Table_ref *tl)
Find a temporary table specified by Table_ref instance in the cache and prepare its TABLE instance fo...
Definition: sql_base.cc:7524
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for LOCK TABLES statement should handle table list elements.
Definition: sql_base.cc:6383
mysql_mutex_t LOCK_open
LOCK_open protects the following variables/objects:
Definition: sql_base.cc:276
bool setup_fields(THD *thd, Access_bitmask want_privilege, bool allow_sum_func, bool split_sum_funcs, bool column_update, const mem_root_deque< Item * > *typed_items, mem_root_deque< Item * > *fields, Ref_item_array ref_item_array)
Resolve a list of expressions and setup appropriate data.
Definition: sql_base.cc:9160
bool close_temporary_tables(THD *thd)
Definition: sql_base.cc:1869
bool lock_dictionary_tables(THD *thd, Table_ref *tables, uint count, uint flags)
Simplified version of lock_tables() call to be used for locking data-dictionary tables when reading o...
Definition: sql_base.cc:7227
void tdc_flush_unused_tables()
Definition: sql_base.cc:10362
Field * find_field_in_table(TABLE *table, const char *name, bool allow_rowid, uint *cached_field_index_ptr)
Find field by name in a base table.
Definition: sql_base.cc:7839
bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for DML statements should handle view - all view routines should be ...
Definition: sql_base.cc:6346
bool close_cached_tables(THD *thd, Table_ref *tables, bool wait_for_refresh, ulong timeout)
Definition: sql_base.cc:1239
bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx, Sroutine_hash_entry *rt, sp_head *sp, bool *need_prelocking) override
Defines how prelocking algorithm for ALTER TABLE statement should handle routines - do nothing as thi...
Definition: sql_base.cc:6405
TABLE * open_table_uncached(THD *thd, const char *path, const char *db, const char *table_name, bool add_to_temporary_tables_list, bool open_in_engine, const dd::Table &table_def)
Open a single table without table caching and don't add it to THD::open_tables.
Definition: sql_base.cc:7337
bool open_temporary_tables(THD *thd, Table_ref *tl_list)
Pre-open temporary tables corresponding to table list elements.
Definition: sql_base.cc:7616
Field * view_ref_found
Definition: sql_base.cc:7495
bool open_tables_for_query(THD *thd, Table_ref *tables, uint flags)
Open all tables for a query or statement, in list started by "tables".
Definition: sql_base.cc:6909
uint cached_table_definitions(void)
Definition: sql_base.cc:531
void table_def_start_shutdown(void)
Notify table definition cache that process of shutting down server has started so it has to keep numb...
Definition: sql_base.cc:503
bool open_trans_system_tables_for_read(THD *thd, Table_ref *table_list)
Open and lock transactional system tables for read.
Definition: sql_base.cc:10567
void drop_temporary_table(THD *thd, Table_ref *table_list)
Drop a temporary table.
Definition: sql_base.cc:2414
bool open_and_lock_tables(THD *thd, Table_ref *tables, uint flags, Prelocking_strategy *prelocking_strategy)
Open all tables in list, locks them and optionally process derived tables.
Definition: sql_base.cc:6682
bool resolve_var_assignments(THD *thd, LEX *lex)
Resolve variable assignments from LEX object.
Definition: sql_base.cc:9116
bool wait_while_table_is_used(THD *thd, TABLE *table, enum ha_extra_function function)
Force all other threads to stop using the table by upgrading metadata lock on it and remove unused TA...
Definition: sql_base.cc:2541
void close_thread_table(THD *thd, TABLE **table_ptr)
Definition: sql_base.cc:1809
Table_ref * find_table_in_global_list(Table_ref *table, const char *db_name, const char *table_name)
Find table in global list.
Definition: sql_base.cc:2149
bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx, Sroutine_hash_entry *rt, sp_head *sp, bool *need_prelocking) override
Defines how prelocking algorithm for DML statements should handle routines:
Definition: sql_base.cc:6232
bool lock_tables(THD *thd, Table_ref *tables, uint counter, uint flags)
Lock all tables in a list.
Definition: sql_base.cc:7004
int setup_ftfuncs(const THD *thd, Query_block *select)
Definition: sql_base.cc:10486
thr_lock_type read_lock_type_for_table(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool routine_modifies_data)
Definition: sql_base.cc:4443
bool table_def_init(void)
Definition: sql_base.cc:478
TABLE * find_table_for_mdl_upgrade(THD *thd, const char *db, const char *table_name, bool no_error)
Find instance of TABLE with upgradable or exclusive metadata lock from the list of open tables,...
Definition: sql_base.cc:3630
void close_tables_for_reopen(THD *thd, Table_ref **tables, const MDL_savepoint &start_of_statement_svp)
Prepare statement for reopening of tables and recalculation of set of prelocked tables.
Definition: sql_base.cc:7281
bool recover_from_failed_open()
Recover from failed attempt of open table by performing requested action.
Definition: sql_base.cc:4281
bool invoke_table_check_constraints(THD *thd, const TABLE *table)
Invoke check constraints defined on the table.
Definition: sql_base.cc:9842
bool open_table(THD *thd, Table_ref *table_list, Open_table_context *ot_ctx)
Open a base table.
Definition: sql_base.cc:2884
bool get_and_lock_tablespace_names(THD *thd, Table_ref *tables_start, Table_ref *tables_end, ulong lock_wait_timeout, uint flags)
Acquire IX metadata locks on tablespace names used by LOCK TABLES or by a DDL statement.
Definition: sql_base.cc:5369
void mark_tmp_table_for_reuse(TABLE *table)
Reset a single temporary table.
Definition: sql_base.cc:1421
bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for ALTER TABLE statement should handle view - do nothing.
Definition: sql_base.cc:6430
int run_before_dml_hook(THD *thd)
Run the server hook called "before_dml".
Definition: sql_base.cc:5296
bool lock_table_names(THD *thd, Table_ref *table_list, Table_ref *table_list_end, ulong lock_wait_timeout, uint flags, Prealloced_array< MDL_request *, 1 > *schema_reqs=nullptr)
Acquire "strong" (SRO, SNW, SNRW) metadata locks on tables used by LOCK TABLES or by a DDL statement.
Definition: sql_base.cc:5498
Field * find_field_in_table_ref(THD *thd, Table_ref *table_list, const char *name, size_t length, const char *item_name, const char *db_name, const char *table_name, Item **ref, Access_bitmask want_privilege, bool allow_rowid, uint *cached_field_index_ptr, bool register_tree_change, Table_ref **actual_table)
Find field in a table reference.
Definition: sql_base.cc:7915
Field * find_field_in_table_sef(TABLE *table, const char *name)
Definition: sql_base.cc:8051
bool open_tables(THD *thd, Table_ref **tables, uint *counter, uint flags, Prelocking_strategy *prelocking_strategy)
Open all tables in list.
Definition: sql_base.cc:5873
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, Table_ref *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for ALTER TABLE statement should handle table list elements.
Definition: sql_base.cc:6418
void intern_close_table(TABLE *entry)
Definition: sql_base.cc:1191
static void free_share(st_blackhole_share *share)
Definition: ha_blackhole.cc:308
static int flags[50]
Definition: hp_test1.cc:40
enum_locked_tables_mode
Type of locked tables mode.
Definition: locked_tables_list.h:47
This file includes constants used by all storage engines.
ha_extra_function
Definition: my_base.h:185
Some integer typedefs for easier portability.
static int count
Definition: myisam_ftdump.cc:45
static uint update
Definition: myisamlog.cc:94
static bool backup
Definition: myisampack.cc:198
ABI for instrumented mutexes.
static char * path
Definition: mysqldump.cc:149
uint counter
Definition: mysqlimport.cc:58
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
PT & ref(PT *tp)
Definition: tablespace_impl.cc:359
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:43
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:76
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:498
const char * table_name
Definition: rules_table_service.cc:56
const char * db_name
Definition: rules_table_service.cc:55
std::list< T, ut::allocator< T > > list
Specialization of list which uses ut_allocator.
Definition: ut0new.h:2879
required string key
Definition: replication_asynchronous_connection_failover.proto:60
required string event
Definition: replication_group_member_actions.proto:32
Bounds_checked_array< Item * > Ref_item_array
Definition: sql_base.h:72
find_item_error_report_type
Definition: sql_base.h:93
@ REPORT_EXCEPT_NOT_FOUND
Definition: sql_base.h:95
@ IGNORE_EXCEPT_NON_UNIQUE
Definition: sql_base.h:98
@ IGNORE_ERRORS
Definition: sql_base.h:96
@ REPORT_ALL_ERRORS
Definition: sql_base.h:94
@ REPORT_EXCEPT_NON_UNIQUE
Definition: sql_base.h:97
enum_tdc_remove_table_type
Definition: sql_base.h:101
@ TDC_RT_REMOVE_UNUSED
Definition: sql_base.h:104
@ TDC_RT_REMOVE_NOT_OWN
Definition: sql_base.h:103
@ TDC_RT_REMOVE_NOT_OWN_KEEP_SHARE
Definition: sql_base.h:105
@ TDC_RT_REMOVE_ALL
Definition: sql_base.h:102
@ TDC_RT_MARK_FOR_REOPEN
Definition: sql_base.h:106
File containing constants that can be used throughout the server.
enum_resolution_type
This enumeration type is used only by the function find_item_in_list to return the info on how an ite...
Definition: sql_const.h:278
case opt name
Definition: sslopt-case.h:29
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3823
Definition: my_bitmap.h:43
Definition: item.h:402
Definition: table.h:4169
This structure is shared between different table objects.
Definition: table.h:701
Definition: table.h:1406
Definition: sql_base.h:375
Definition: completion_hash.h:35
handlerton is a singleton structure - one instance per storage engine - to provide access to storage ...
Definition: handler.h:2734
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:50
thr_lock_type
Definition: thr_lock.h:51
This file defines all base public constants related to triggers in MySQL.
enum_trigger_event_type
Constants to enumerate possible event types on which triggers can be fired.
Definition: trigger_def.h:42