MySQL  8.0.27
Source Code Documentation
sql_base.h
Go to the documentation of this file.
1 /* Copyright (c) 2010, 2021, 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_BASE_INCLUDED
24 #define SQL_BASE_INCLUDED
25 
26 #include <stddef.h>
27 #include <sys/types.h>
28 #include <memory>
29 #include <string>
30 
31 #include "lex_string.h"
32 #include "map_helpers.h"
33 #include "mem_root_deque.h"
34 #include "my_base.h" // ha_extra_function
35 #include "my_inttypes.h"
37 #include "prealloced_array.h" // Prealloced_array
38 #include "sql/locked_tables_list.h" // enum_locked_tables_mode
39 #include "sql/mdl.h" // MDL_savepoint
40 #include "sql/sql_array.h" // Bounds_checked_array
41 #include "sql/sql_const.h" // enum_resolution_type
42 #include "sql/trigger_def.h" // enum_trigger_event_type
43 #include "thr_lock.h" // thr_lock_type
44 
45 class COPY_INFO;
46 class Field;
47 class Item;
48 class Item_ident;
49 class Open_table_context;
50 class Open_tables_backup;
52 class Query_tables_list;
53 class Query_block;
55 class THD;
56 class sp_head;
57 struct LEX;
58 struct MY_BITMAP;
60 struct OPEN_TABLE_LIST;
61 struct TABLE;
62 struct TABLE_LIST;
63 struct TABLE_SHARE;
64 struct handlerton;
65 template <class T>
66 class List;
67 template <class T>
68 class List_iterator;
69 template <class T>
70 class Mem_root_array;
71 
73 namespace dd {
74 class Table;
75 } // namespace dd
76 
77 #define TEMP_PREFIX "MY"
78 
79 /* Defines for use with openfrm, openprt and openfrd */
80 
81 #define READ_ALL 1 /* openfrm: Read all parameters */
82 #define EXTRA_RECORD 8 /* Reservera plats f|r extra record */
83 #define DELAYED_OPEN 4096 /* Open table later */
84 /**
85  If set, open_table_from_share() will skip calling get_new_handler() to
86  create a new handler object for the table. Designed to be used when
87  opening a table from inside storage engines.
88 */
89 #define SKIP_NEW_HANDLER 32768
90 
97 };
98 
105 };
106 
107 extern mysql_mutex_t LOCK_open;
108 bool table_def_init(void);
109 void table_def_free(void);
110 void table_def_start_shutdown(void);
111 void assign_new_table_id(TABLE_SHARE *share);
113 size_t get_table_def_key(const TABLE_LIST *table_list, const char **key);
114 TABLE_SHARE *get_table_share(THD *thd, const char *db, const char *table_name,
115  const char *key, size_t key_length, bool open_view,
116  bool open_secondary = false);
117 void release_table_share(TABLE_SHARE *share);
118 
119 TABLE *open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update,
120  uint lock_flags);
121 
122 /* mysql_lock_tables() and open_table() flags bits */
123 #define MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK 0x0001
124 #define MYSQL_OPEN_IGNORE_FLUSH 0x0002
125 /* MYSQL_OPEN_TEMPORARY_ONLY (0x0004) is not used anymore. */
126 #define MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY 0x0008
127 #define MYSQL_LOCK_LOG_TABLE 0x0010
128 /**
129  Do not try to acquire a metadata lock on the table: we
130  already have one.
131 */
132 #define MYSQL_OPEN_HAS_MDL_LOCK 0x0020
133 /**
134  If in locked tables mode, ignore the locked tables and get
135  a new instance of the table.
136 */
137 #define MYSQL_OPEN_GET_NEW_TABLE 0x0040
138 /* 0x0080 used to be MYSQL_OPEN_SKIP_TEMPORARY */
139 /** Fail instead of waiting when conficting metadata lock is discovered. */
140 #define MYSQL_OPEN_FAIL_ON_MDL_CONFLICT 0x0100
141 /** Open tables using MDL_SHARED lock instead of one specified in parser. */
142 #define MYSQL_OPEN_FORCE_SHARED_MDL 0x0200
143 /**
144  Open tables using MDL_SHARED_HIGH_PRIO lock instead of one specified
145  in parser.
146 */
147 #define MYSQL_OPEN_FORCE_SHARED_HIGH_PRIO_MDL 0x0400
148 /**
149  When opening or locking the table, use the maximum timeout
150  (LONG_TIMEOUT = 1 year) rather than the user-supplied timeout value.
151 */
152 #define MYSQL_LOCK_IGNORE_TIMEOUT 0x0800
153 /**
154  When acquiring "strong" (SNW, SNRW, X) metadata locks on tables to
155  be open do not acquire global, tablespace-scope and schema-scope IX locks.
156 */
157 #define MYSQL_OPEN_SKIP_SCOPED_MDL_LOCK 0x1000
158 /**
159  When opening or locking a replication table through an internal
160  operation rather than explicitly through an user thread.
161 */
162 #define MYSQL_LOCK_RPL_INFO_TABLE 0x2000
163 /**
164  Only check THD::killed if waits happen (e.g. wait on MDL, wait on
165  table flush, wait on thr_lock.c locks) while opening and locking table.
166 */
167 #define MYSQL_OPEN_IGNORE_KILLED 0x4000
168 /**
169  For new TABLE instances constructed do not open table in the storage
170  engine. Existing TABLE instances for which there is a handler object
171  which represents table open in storage engines can still be used.
172 */
173 #define MYSQL_OPEN_NO_NEW_TABLE_IN_SE 0x8000
174 /** Open a shadow copy of a table from a secondary storage engine. */
175 #define MYSQL_OPEN_SECONDARY_ENGINE 0x10000
176 
177 /** Please refer to the internals manual. */
178 #define MYSQL_OPEN_REOPEN \
179  (MYSQL_OPEN_IGNORE_FLUSH | MYSQL_OPEN_IGNORE_GLOBAL_READ_LOCK | \
180  MYSQL_LOCK_IGNORE_GLOBAL_READ_ONLY | MYSQL_LOCK_IGNORE_TIMEOUT | \
181  MYSQL_OPEN_IGNORE_KILLED | MYSQL_OPEN_GET_NEW_TABLE | \
182  MYSQL_OPEN_HAS_MDL_LOCK)
183 
184 bool open_table(THD *thd, TABLE_LIST *table_list, Open_table_context *ot_ctx);
185 
186 TABLE *open_table_uncached(THD *thd, const char *path, const char *db,
187  const char *table_name,
188  bool add_to_temporary_tables_list,
189  bool open_in_engine, const dd::Table &table_def);
190 TABLE *find_locked_table(TABLE *list, const char *db, const char *table_name);
192  Query_tables_list *prelocking_ctx,
193  TABLE_LIST *table_list,
194  bool routine_modifies_data);
195 
196 bool mysql_rm_tmp_tables(void);
197 bool rm_temporary_table(THD *thd, handlerton *base, const char *path,
198  const dd::Table *table_def);
199 void close_tables_for_reopen(THD *thd, TABLE_LIST **tables,
200  const MDL_savepoint &start_of_statement_svp);
201 TABLE *find_temporary_table(THD *thd, const char *db, const char *table_name);
202 TABLE *find_temporary_table(THD *thd, const TABLE_LIST *tl);
203 void close_thread_tables(THD *thd);
205  THD *thd, COPY_INFO *optype_info, const mem_root_deque<Item *> &fields,
206  const mem_root_deque<Item *> &values, TABLE *table,
207  enum enum_trigger_event_type event, int num_fields,
208  bool raise_autoinc_has_expl_non_null_val, bool *is_row_changed);
210  const mem_root_deque<Item *> &values,
211  TABLE *table,
213  int num_fields);
214 bool resolve_var_assignments(THD *thd, LEX *lex);
215 bool insert_fields(THD *thd, Query_block *query_block, const char *db_name,
216  const char *table_name, mem_root_deque<Item *> *fields,
217  mem_root_deque<Item *>::iterator *it, bool any_privileges);
218 bool setup_fields(THD *thd, ulong want_privilege, bool allow_sum_func,
219  bool split_sum_funcs, bool column_update,
220  const mem_root_deque<Item *> *typed_items,
221  mem_root_deque<Item *> *fields,
222  Ref_item_array ref_item_array);
223 bool fill_record(THD *thd, TABLE *table, const mem_root_deque<Item *> &fields,
224  const mem_root_deque<Item *> &values, MY_BITMAP *bitmap,
225  MY_BITMAP *insert_into_fields_bitmap,
226  bool raise_autoinc_has_expl_non_null_val);
227 bool fill_record(THD *thd, TABLE *table, Field **field,
228  const mem_root_deque<Item *> &values, MY_BITMAP *bitmap,
229  MY_BITMAP *insert_into_fields_bitmap,
230  bool raise_autoinc_has_expl_non_null_val);
231 
232 bool check_record(THD *thd, Field **ptr);
233 
234 /**
235  Invoke check constraints defined on the table.
236 
237  @param thd Thread handle.
238  @param table Instance of TABLE.
239 
240  @retval false If all enforced check constraints are satisfied.
241  @retval true Otherwise. THD::is_error() may be "true" in this case.
242 */
243 bool invoke_table_check_constraints(THD *thd, const TABLE *table);
244 
245 Field *find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *first_table,
246  TABLE_LIST *last_table, Item **ref,
248  ulong want_privilege, bool register_tree_change);
249 Field *find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
250  const char *name, size_t length,
251  const char *item_name, const char *db_name,
252  const char *table_name, Item **ref,
253  ulong want_privilege, bool allow_rowid,
254  uint *cached_field_index_ptr,
255  bool register_tree_change,
256  TABLE_LIST **actual_table);
257 Field *find_field_in_table(TABLE *table, const char *name, bool allow_rowid,
258  uint *cached_field_index_ptr);
259 Field *find_field_in_table_sef(TABLE *table, const char *name);
261  uint *counter,
263  enum_resolution_type *resolution);
265  mem_root_deque<TABLE_LIST *> *from_clause,
266  Name_resolution_context *context);
267 bool wait_while_table_is_used(THD *thd, TABLE *table,
268  enum ha_extra_function function);
269 
270 void update_non_unique_table_error(TABLE_LIST *update, const char *operation,
271  TABLE_LIST *duplicate);
272 int setup_ftfuncs(const THD *thd, Query_block *select);
273 bool init_ftfuncs(THD *thd, Query_block *select);
274 int run_before_dml_hook(THD *thd);
275 bool get_and_lock_tablespace_names(THD *thd, TABLE_LIST *tables_start,
276  TABLE_LIST *tables_end,
277  ulong lock_wait_timeout, uint flags);
278 bool lock_table_names(
279  THD *thd, TABLE_LIST *table_list, TABLE_LIST *table_list_end,
280  ulong lock_wait_timeout, uint flags,
281  Prealloced_array<MDL_request *, 1> *schema_reqs = nullptr);
282 bool open_tables(THD *thd, TABLE_LIST **tables, uint *counter, uint flags,
283  Prelocking_strategy *prelocking_strategy);
284 /* open_and_lock_tables */
285 bool open_and_lock_tables(THD *thd, TABLE_LIST *tables, uint flags,
286  Prelocking_strategy *prelocking_strategy);
287 /* simple open_and_lock_tables for single table */
289  thr_lock_type lock_type, uint flags,
290  Prelocking_strategy *prelocking_strategy);
291 bool open_tables_for_query(THD *thd, TABLE_LIST *tables, uint flags);
292 bool lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags);
293 bool lock_dictionary_tables(THD *thd, TABLE_LIST *tables, uint count,
294  uint flags);
295 void free_io_cache(TABLE *entry);
297 void close_thread_table(THD *thd, TABLE **table_ptr);
298 bool close_temporary_tables(THD *thd);
299 TABLE_LIST *unique_table(const TABLE_LIST *table, TABLE_LIST *table_list,
300  bool check_alias);
301 void drop_temporary_table(THD *thd, TABLE_LIST *table_list);
302 void close_temporary_table(THD *thd, TABLE *table, bool free_share,
303  bool delete_table);
304 void close_temporary(THD *thd, TABLE *table, bool free_share,
305  bool delete_table);
306 bool rename_temporary_table(THD *thd, TABLE *table, const char *new_db,
307  const char *table_name);
308 bool open_temporary_tables(THD *thd, TABLE_LIST *tl_list);
309 bool open_temporary_table(THD *thd, TABLE_LIST *tl);
310 
311 /* Functions to work with system tables. */
312 bool open_trans_system_tables_for_read(THD *thd, TABLE_LIST *table_list);
313 void close_trans_system_tables(THD *thd);
314 void close_mysql_tables(THD *thd);
315 TABLE *open_log_table(THD *thd, TABLE_LIST *one_table,
318 
319 bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool wait_for_refresh,
320  ulong timeout);
321 
322 /**
323  Close all open instances of the table but keep the MDL lock.
324 
325  Works both under LOCK TABLES and in the normal mode.
326  Removes all closed instances of the table from the table cache.
327 
328  @param thd Thread context.
329  @param share Table share, but is just a handy way to
330  access the table cache key.
331  @param remove_from_locked_tables
332  True if the table is being dropped.
333  In that case the documented behaviour is to
334  implicitly remove the table from LOCK TABLES list.
335  @param skip_table TABLE instance that should be kept open.
336 
337  @pre Must be called with an X MDL lock on the table.
338 */
339 void close_all_tables_for_name(THD *thd, TABLE_SHARE *share,
340  bool remove_from_locked_tables,
341  TABLE *skip_table);
342 
343 /**
344  Close all open instances of the table but keep the MDL lock.
345 
346  Works both under LOCK TABLES and in the normal mode.
347  Removes all closed instances of the table from the table cache.
348 
349  @param thd Thread context.
350  @param db Database name.
351  @param table_name Table name.
352  @param remove_from_locked_tables
353  True if the table is being dropped.
354  In that case the documented behaviour is to
355  implicitly remove the table from LOCK TABLES list.
356 
357  @pre Must be called with an X MDL lock on the table.
358 */
359 void close_all_tables_for_name(THD *thd, const char *db, const char *table_name,
360  bool remove_from_locked_tables);
361 
362 OPEN_TABLE_LIST *list_open_tables(THD *thd, const char *db, const char *wild);
363 void tdc_remove_table(THD *thd, enum_tdc_remove_table_type remove_type,
364  const char *db, const char *table_name, bool has_lock);
366 TABLE *find_table_for_mdl_upgrade(THD *thd, const char *db,
367  const char *table_name, bool no_error);
368 void mark_tmp_table_for_reuse(TABLE *table);
369 
370 extern Item **not_found_item;
371 extern Field *not_found_field;
372 extern Field *view_ref_found;
373 
375  void operator()(TABLE_SHARE *share) const;
376 };
377 extern malloc_unordered_map<std::string,
378  std::unique_ptr<TABLE_SHARE, Table_share_deleter>>
380 
382  const char *table_name);
383 
384 /**
385  An abstract class for a strategy specifying how the prelocking
386  algorithm should extend the prelocking set while processing
387  already existing elements in the set.
388 */
389 
391  public:
392  virtual ~Prelocking_strategy() = default;
393 
394  virtual bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
395  Sroutine_hash_entry *rt, sp_head *sp,
396  bool *need_prelocking) = 0;
397  virtual bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
398  TABLE_LIST *table_list, bool *need_prelocking) = 0;
399  virtual bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
400  TABLE_LIST *table_list, bool *need_prelocking) = 0;
401 };
402 
403 /**
404  A Strategy for prelocking algorithm suitable for DML statements.
405 
406  Ensures that all tables used by all statement's SF/SP/triggers and
407  required for foreign key checks are prelocked and SF/SPs used are
408  cached.
409 */
410 
412  public:
413  bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
414  Sroutine_hash_entry *rt, sp_head *sp,
415  bool *need_prelocking) override;
416  bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
417  TABLE_LIST *table_list, bool *need_prelocking) override;
418  bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
419  TABLE_LIST *table_list, bool *need_prelocking) override;
420 };
421 
422 /**
423  A strategy for prelocking algorithm to be used for LOCK TABLES
424  statement.
425 */
426 
428  bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
429  TABLE_LIST *table_list, bool *need_prelocking) override;
430 };
431 
432 /**
433  Strategy for prelocking algorithm to be used for ALTER TABLE statements.
434 
435  Unlike DML or LOCK TABLES strategy, it doesn't
436  prelock triggers, views or stored routines, since they are not
437  used during ALTER.
438 */
439 
441  public:
442  bool handle_routine(THD *thd, Query_tables_list *prelocking_ctx,
443  Sroutine_hash_entry *rt, sp_head *sp,
444  bool *need_prelocking) override;
445  bool handle_table(THD *thd, Query_tables_list *prelocking_ctx,
446  TABLE_LIST *table_list, bool *need_prelocking) override;
447  bool handle_view(THD *thd, Query_tables_list *prelocking_ctx,
448  TABLE_LIST *table_list, bool *need_prelocking) override;
449 };
450 
451 inline bool open_tables(THD *thd, TABLE_LIST **tables, uint *counter,
452  uint flags) {
453  DML_prelocking_strategy prelocking_strategy;
454 
455  return open_tables(thd, tables, counter, flags, &prelocking_strategy);
456 }
457 
459  thr_lock_type lock_type, uint flags) {
460  DML_prelocking_strategy prelocking_strategy;
461 
462  return open_n_lock_single_table(thd, table_l, lock_type, flags,
463  &prelocking_strategy);
464 }
465 
466 // open_and_lock_tables with default prelocking strategy
467 inline bool open_and_lock_tables(THD *thd, TABLE_LIST *tables, uint flags) {
468  DML_prelocking_strategy prelocking_strategy;
469 
470  return open_and_lock_tables(thd, tables, flags, &prelocking_strategy);
471 }
472 
473 /**
474  Get an existing table definition from the table definition cache.
475 
476  Search the table definition cache for a share with the given key.
477  If the share exists or if it is in the process of being opened
478  by another thread (m_open_in_progress flag is true) return share.
479  Do not wait for share opening to finish.
480 
481  @param db database name.
482  @param table_name table name.
483 
484  @retval nulltpr a share for the table does not exist in the cache
485  @retval != nulltpr pointer to existing share in the cache
486 */
487 
488 TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);
489 
490 /**
491  A context of open_tables() function, used to recover
492  from a failed open_table() or open_routine() attempt.
493 */
494 
496  public:
504  };
506 
509  TABLE_LIST *table);
510 
512 
513  /**
514  When doing a back-off, we close all tables acquired by this
515  statement. Return an MDL savepoint taken at the beginning of
516  the statement, so that we can rollback to it before waiting on
517  locks.
518  */
521  }
522 
523  inline ulong get_timeout() const { return m_timeout; }
524 
525  uint get_flags() const { return m_flags; }
526 
527  /**
528  Set flag indicating that we have already acquired metadata lock
529  protecting this statement against GRL while opening tables.
530  */
532 
535  }
536 
537  bool can_back_off() const { return !m_has_locks; }
538 
539  private:
540  /* THD for which tables are opened. */
542  /**
543  For OT_DISCOVER, OT_REPAIR and OT_FIX_ROW_TYPE actions, the table list
544  element for the table which definition should be re-discovered/updated
545  or which should be repaired.
546  */
549  /**
550  Lock timeout in seconds. Initialized to LONG_TIMEOUT when opening system
551  tables or to the "lock_wait_timeout" system variable for regular tables.
552  */
553  ulong m_timeout;
554  /* open_table() flags. */
556  /** Back off action. */
558  /**
559  Whether we had any locks when this context was created.
560  If we did, they are from the previous statement of a transaction,
561  and we can't safely do back-off (and release them).
562  */
564  /**
565  Indicates that in the process of opening tables we have acquired
566  protection against global read lock.
567  */
569 };
570 
571 /**
572  Check if given TABLE_LIST is a acl table and is being read and not
573  in LOCK TABLE mode.
574 
575  @param tl TABLE_LIST pointing to the table.
576  @param ltm THD->locked_tables_mode enum.
577 
578  @return true if acl table is being read, otherwise false.
579 */
580 bool is_acl_table_in_non_LTM(const TABLE_LIST *tl,
581  enum enum_locked_tables_mode ltm);
582 
583 #endif /* SQL_BASE_INCLUDED */
Strategy for prelocking algorithm to be used for ALTER TABLE statements.
Definition: sql_base.h:440
This class encapsulates a data change operation.
Definition: sql_data_change.h:73
A Strategy for prelocking algorithm suitable for DML statements.
Definition: sql_base.h:411
Definition: field.h:590
Definition: item.h:3755
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:802
Definition: sql_list.h:570
Definition: sql_list.h:431
A strategy for prelocking algorithm to be used for LOCK TABLES statement.
Definition: sql_base.h:427
Savepoint for MDL context.
Definition: mdl.h:1312
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:418
A context of open_tables() function, used to recover from a failed open_table() or open_routine() att...
Definition: sql_base.h:495
uint m_flags
Definition: sql_base.h:555
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:531
enum enum_open_table_action m_action
Back off action.
Definition: sql_base.h:557
enum_open_table_action
Definition: sql_base.h:497
@ OT_FIX_ROW_TYPE
Definition: sql_base.h:503
@ OT_DISCOVER
Definition: sql_base.h:501
@ OT_BACKOFF_AND_RETRY
Definition: sql_base.h:499
@ OT_REOPEN_TABLES
Definition: sql_base.h:500
@ OT_NO_ACTION
Definition: sql_base.h:498
@ OT_REPAIR
Definition: sql_base.h:502
ulong get_timeout() const
Definition: sql_base.h:523
uint get_flags() const
Definition: sql_base.h:525
bool has_protection_against_grl() const
Definition: sql_base.h:533
TABLE_LIST * 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:547
ulong m_timeout
Lock timeout in seconds.
Definition: sql_base.h:553
THD * m_thd
Definition: sql_base.h:541
bool m_has_locks
Whether we had any locks when this context was created.
Definition: sql_base.h:563
bool can_back_off() const
Definition: sql_base.h:537
bool can_recover_from_failed_open() const
Definition: sql_base.h:511
MDL_savepoint m_start_of_statement_svp
Definition: sql_base.h:548
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:568
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:519
Storage for backup of Open_tables_state.
Definition: sql_class.h:579
A typesafe replacement for DYNAMIC_ARRAY.
Definition: prealloced_array.h:70
An abstract class for a strategy specifying how the prelocking algorithm should extend the prelocking...
Definition: sql_base.h:390
virtual bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking)=0
virtual ~Prelocking_strategy()=default
virtual bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking)=0
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:1123
Definition: sql_lex.h:2460
Structure that represents element in the set of stored routines used by statement or routine.
Definition: sp.h:222
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_class.h:821
Definition: table.h:46
std::unordered_map, but with my_malloc, so that you can track the memory used using PSI memory keys.
Definition: map_helpers.h:147
sp_head represents one instance of a stored program.
Definition: sp_head.h:379
A table definition from the master.
Definition: rpl_utility.h:247
static bool report_error(THD *thd, int error_code, Sql_condition::enum_severity_level level, Args... args)
Definition: error_handler.cc:290
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:9487
void free_io_cache(TABLE *entry)
Definition: sql_base.cc:1115
TABLE * open_log_table(THD *thd, TABLE_LIST *one_table, Open_tables_backup *backup)
Open a log table.
Definition: sql_base.cc:10465
bool lock_table_names(THD *thd, TABLE_LIST *table_list, TABLE_LIST *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:5365
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:2253
void assign_new_table_id(TABLE_SHARE *share)
Definition: sql_base.cc:3590
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for DML statements should handle table list elements:
Definition: sql_base.cc:6153
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:997
void release_table_share(TABLE_SHARE *share)
Mark that we are not using table share anymore.
Definition: sql_base.cc:963
bool get_and_lock_tablespace_names(THD *thd, TABLE_LIST *tables_start, TABLE_LIST *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:5236
size_t get_table_def_key(const TABLE_LIST *table_list, const char **key)
Get table cache key for a table list element.
Definition: sql_base.cc:418
bool rename_temporary_table(THD *thd, TABLE *table, const char *new_db, const char *table_name)
Definition: sql_base.cc:2410
thr_lock_type read_lock_type_for_table(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool routine_modifies_data)
Definition: sql_base.cc:4331
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:9268
TABLE_LIST * unique_table(const TABLE_LIST *table, TABLE_LIST *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:2180
bool mysql_rm_tmp_tables(void)
Drop all temporary tables which have been left from previous server run.
Definition: sql_base.cc:10073
void close_temporary(THD *thd, TABLE *table, bool free_share, bool delete_table)
Definition: sql_base.cc:2380
bool lock_tables(THD *thd, TABLE_LIST *tables, uint counter, uint flags)
Lock all tables in a list.
Definition: sql_base.cc:6797
TABLE * open_ltable(THD *thd, TABLE_LIST *table_list, thr_lock_type update, uint lock_flags)
Definition: sql_base.cc:6461
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:1533
Field * find_field_in_tables(THD *thd, Item_ident *item, TABLE_LIST *first_table, TABLE_LIST *last_table, Item **ref, find_item_error_report_type report_error, ulong want_privilege, bool register_tree_change)
Definition: sql_base.cc:7882
malloc_unordered_map< std::string, std::unique_ptr< TABLE_SHARE, Table_share_deleter > > * table_def_cache
Definition: sql_base.cc:309
bool open_table(THD *thd, TABLE_LIST *table_list, Open_table_context *ot_ctx)
Open a base table.
Definition: sql_base.cc:2787
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:3495
Item ** find_item_in_list(THD *thd, Item *item, mem_root_deque< Item * > *items, uint *counter, find_item_error_report_type report_error, enum_resolution_type *resolution)
Definition: sql_base.cc:8097
bool check_record(THD *thd, Field **ptr)
Check the NOT NULL constraint on all the fields of the current record.
Definition: sql_base.cc:9592
bool rm_temporary_table(THD *thd, handlerton *base, const char *path, const dd::Table *table_def)
Delete a temporary table.
Definition: sql_base.cc:7255
bool init_ftfuncs(THD *thd, Query_block *select)
Definition: sql_base.cc:10299
bool setup_fields(THD *thd, ulong 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:8958
OPEN_TABLE_LIST * list_open_tables(THD *thd, const char *db, const char *wild)
Definition: sql_base.cc:1024
bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *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:6218
bool open_tables(THD *thd, TABLE_LIST **tables, uint *counter, uint flags, Prelocking_strategy *prelocking_strategy)
Open all tables in list.
Definition: sql_base.cc:5741
Field * find_field_in_table_ref(THD *thd, TABLE_LIST *table_list, const char *name, size_t length, const char *item_name, const char *db_name, const char *table_name, Item **ref, ulong want_privilege, bool allow_rowid, uint *cached_field_index_ptr, bool register_tree_change, TABLE_LIST **actual_table)
Find field in a table reference.
Definition: sql_base.cc:7697
void close_temporary_table(THD *thd, TABLE *table, bool free_share, bool delete_table)
Definition: sql_base.cc:2341
bool setup_natural_join_row_types(THD *thd, mem_root_deque< TABLE_LIST * > *from_clause, Name_resolution_context *context)
Definition: sql_base.cc:8837
TABLE_LIST * find_table_in_global_list(TABLE_LIST *table, const char *db_name, const char *table_name)
Find table in global list.
Definition: sql_base.cc:2052
bool open_tables_for_query(THD *thd, TABLE_LIST *tables, uint flags)
Open all tables for a query or statement, in list started by "tables".
Definition: sql_base.cc:6715
void drop_temporary_table(THD *thd, TABLE_LIST *table_list)
Drop a temporary table.
Definition: sql_base.cc:2317
void operator()(TABLE_SHARE *share) const
Definition: sql_base.cc:439
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:663
Field * find_field_in_table_sef(TABLE *table, const char *name)
Definition: sql_base.cc:7833
bool is_acl_table_in_non_LTM(const TABLE_LIST *tl, enum enum_locked_tables_mode ltm)
Check if given TABLE_LIST is a acl table and is being read and not in LOCK TABLE mode.
Definition: sql_base.cc:5634
bool close_cached_tables(THD *thd, TABLE_LIST *tables, bool wait_for_refresh, ulong timeout)
Definition: sql_base.cc:1143
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:1464
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:3528
TABLE * open_n_lock_single_table(THD *thd, TABLE_LIST *table_l, thr_lock_type lock_type, uint flags, Prelocking_strategy *prelocking_strategy)
Open and lock one table.
Definition: sql_base.cc:6411
void table_def_free(void)
Definition: sql_base.cc:491
Open_table_context(THD *thd, uint flags)
Open_table_context.
Definition: sql_base.cc:4035
void close_log_table(THD *thd, Open_tables_backup *backup)
Close a log table.
Definition: sql_base.cc:10498
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:10200
Field * not_found_field
Definition: sql_base.cc:7287
void close_tables_for_reopen(THD *thd, TABLE_LIST **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:7074
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:9768
void close_mysql_tables(THD *thd)
A helper function to close a mysql.
Definition: sql_base.cc:10447
void close_trans_system_tables(THD *thd)
Close transactional system tables, opened with open_trans_system_tables_for_read().
Definition: sql_base.cc:10422
bool lock_dictionary_tables(THD *thd, TABLE_LIST *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:7020
mysql_mutex_t LOCK_open
LOCK_open protects the following variables/objects:
Definition: sql_base.cc:248
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for LOCK TABLES statement should handle table list elements.
Definition: sql_base.cc:6255
bool close_temporary_tables(THD *thd)
Definition: sql_base.cc:1773
void update_non_unique_table_error(TABLE_LIST *update, const char *operation, TABLE_LIST *duplicate)
Issue correct error message in case we found 2 duplicate tables which prevent some update operation.
Definition: sql_base.cc:2209
void tdc_flush_unused_tables()
Definition: sql_base.cc:10152
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:6277
bool open_and_lock_tables(THD *thd, TABLE_LIST *tables, uint flags, Prelocking_strategy *prelocking_strategy)
Open all tables in list, locks them and optionally process derived tables.
Definition: sql_base.cc:6554
bool open_temporary_table(THD *thd, TABLE_LIST *tl)
Find a temporary table specified by TABLE_LIST instance in the cache and prepare its TABLE instance f...
Definition: sql_base.cc:7317
Field * view_ref_found
Definition: sql_base.cc:7288
uint cached_table_definitions(void)
Definition: sql_base.cc:503
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:475
Item ** not_found_item
Definition: sql_base.cc:8095
bool resolve_var_assignments(THD *thd, LEX *lex)
Resolve variable assignments from LEX object.
Definition: sql_base.cc:8914
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:2444
bool open_trans_system_tables_for_read(THD *thd, TABLE_LIST *table_list)
Open and lock transactional system tables for read.
Definition: sql_base.cc:10356
bool open_temporary_tables(THD *thd, TABLE_LIST *tl_list)
Pre-open temporary tables corresponding to table list elements.
Definition: sql_base.cc:7399
void close_thread_table(THD *thd, TABLE **table_ptr)
Definition: sql_base.cc:1713
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:6104
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:7621
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:7130
int setup_ftfuncs(const THD *thd, Query_block *select)
Definition: sql_base.cc:10275
bool table_def_init(void)
Definition: sql_base.cc:450
bool handle_table(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for ALTER TABLE statement should handle table list elements.
Definition: sql_base.cc:6290
bool recover_from_failed_open()
Recover from failed attempt of open table by performing requested action.
Definition: sql_base.cc:4169
bool invoke_table_check_constraints(THD *thd, const TABLE *table)
Invoke check constraints defined on the table.
Definition: sql_base.cc:9633
void mark_tmp_table_for_reuse(TABLE *table)
Reset a single temporary table.
Definition: sql_base.cc:1325
int run_before_dml_hook(THD *thd)
Run the server hook called "before_dml".
Definition: sql_base.cc:5183
bool request_backoff_action(enum_open_table_action action_arg, TABLE_LIST *table)
Check if we can back-off and set back off action if we can.
Definition: sql_base.cc:4055
bool handle_view(THD *thd, Query_tables_list *prelocking_ctx, TABLE_LIST *table_list, bool *need_prelocking) override
Defines how prelocking algorithm for ALTER TABLE statement should handle view - do nothing.
Definition: sql_base.cc:6302
void intern_close_table(TABLE *entry)
Definition: sql_base.cc:1099
static void free_share(st_blackhole_share *share)
Definition: ha_blackhole.cc:281
static int flags[50]
Definition: hp_test1.cc:39
enum_locked_tables_mode
Type of locked tables mode.
Definition: locked_tables_list.h:44
static uint key_length
Definition: mi_test1.cc:42
This file includes constants used by all storage engines.
ha_extra_function
Definition: my_base.h:183
Some integer typedefs for easier portability.
static int count
Definition: myisam_ftdump.cc:42
static uint update
Definition: myisamlog.cc:90
static bool backup
Definition: myisampack.cc:194
ABI for instrumented mutexes.
static char * path
Definition: mysqldump.cc:130
uint counter
Definition: mysqlimport.cc:53
PT & ref(PT *tp)
Definition: tablespace_impl.cc:358
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:42
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:75
static bool timeout(bool(*wait_condition)())
Timeout function.
Definition: log0meb.cc:494
const char * table_name
Definition: rules_table_service.cc:55
const char * db_name
Definition: rules_table_service.cc:54
required string key
Definition: replication_asynchronous_connection_failover.proto:59
required string event
Definition: replication_group_member_actions.proto:31
Bounds_checked_array< Item * > Ref_item_array
Definition: sql_base.h:70
find_item_error_report_type
Definition: sql_base.h:91
@ REPORT_EXCEPT_NOT_FOUND
Definition: sql_base.h:93
@ IGNORE_EXCEPT_NON_UNIQUE
Definition: sql_base.h:96
@ IGNORE_ERRORS
Definition: sql_base.h:94
@ REPORT_ALL_ERRORS
Definition: sql_base.h:92
@ REPORT_EXCEPT_NON_UNIQUE
Definition: sql_base.h:95
enum_tdc_remove_table_type
Definition: sql_base.h:99
@ TDC_RT_REMOVE_UNUSED
Definition: sql_base.h:102
@ TDC_RT_REMOVE_NOT_OWN
Definition: sql_base.h:101
@ TDC_RT_REMOVE_NOT_OWN_KEEP_SHARE
Definition: sql_base.h:103
@ TDC_RT_REMOVE_ALL
Definition: sql_base.h:100
@ TDC_RT_MARK_FOR_REOPEN
Definition: sql_base.h:104
File containing constants that can be used throughout the server.
enum_resolution_type
Definition: sql_const.h:425
case opt name
Definition: sslopt-case.h:32
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3654
Definition: my_bitmap.h:41
Definition: item.h:395
Definition: table.h:3984
Definition: table.h:2694
This structure is shared between different table objects.
Definition: table.h:688
Definition: table.h:1394
Definition: sql_base.h:374
Definition: completion_hash.h:34
handlerton is a singleton structure - one instance per storage engine - to provide access to storage ...
Definition: handler.h:2391
An instrumented mutex structure.
Definition: mysql_mutex_bits.h:49
thr_lock_type
Definition: thr_lock.h:50
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:41
unsigned int uint
Definition: uca-dump.cc:29