MySQL 8.4.5
Source Code Documentation
table.h
Go to the documentation of this file.
1#ifndef TABLE_INCLUDED
2#define TABLE_INCLUDED
3
4/* Copyright (c) 2000, 2025, Oracle and/or its affiliates.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License, version 2.0,
8 as published by the Free Software Foundation.
9
10 This program is designed to work with certain software (including
11 but not limited to OpenSSL) that is licensed under separate terms,
12 as designated in a particular file or component or in included license
13 documentation. The authors of MySQL hereby grant you an additional
14 permission to link the program and your derivative works with the
15 separately licensed software that they have either included with
16 the program or referenced in the documentation.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License, version 2.0, for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
26
27#include <assert.h>
28#include <string.h>
29#include <sys/types.h>
30#include <string>
31
32#include "field_types.h"
33#include "lex_string.h"
34#include "map_helpers.h"
35#include "mem_root_deque.h"
36#include "my_alloc.h"
37#include "my_base.h"
38#include "my_bitmap.h"
39#include "my_compiler.h"
40#include "mysql/binlog/event/table_id.h" // Table_id
41
42#include "my_inttypes.h"
43#include "my_sys.h"
44#include "my_table_map.h"
48#include "sql/auth/auth_acls.h" // Access_bitmask
49#include "sql/dd/types/foreign_key.h" // dd::Foreign_key::enum_rule
50#include "sql/enum_query_type.h" // enum_query_type
51#include "sql/key.h"
52#include "sql/key_spec.h"
53#include "sql/mdl.h" // MDL_wait_for_subgraph
54#include "sql/mem_root_array.h"
55#include "sql/mysqld_cs.h"
56#include "sql/opt_costmodel.h" // Cost_model_table
57#include "sql/partition_info.h"
58#include "sql/record_buffer.h" // Record_buffer
59#include "sql/sql_bitmap.h" // Bitmap
60#include "sql/sql_const.h"
61#include "sql/sql_list.h"
62#include "sql/sql_plist.h"
63#include "sql/sql_plugin_ref.h"
64#include "sql/sql_sort.h" // Sort_result
65#include "sql/tablesample.h"
66#include "thr_lock.h"
67#include "typelib.h"
68
69class Field;
70class Field_longlong;
71
72namespace histograms {
73class Histogram;
74} // namespace histograms
75
78class COND_EQUAL;
79class Field_json;
80/* Structs that defines the TABLE */
81class File_parser;
82class Value_generator;
83class GRANT_TABLE;
84class Handler_share;
85class Index_hint;
86class Item;
87class Item_field;
90class Json_wrapper;
91class Name_string;
92class Opt_hints_qb;
93class Opt_hints_table;
95class Query_block;
98class SortingIterator;
99class String;
100class THD;
102class Table_histograms;
104class Table_ref;
106class Temp_table_param;
107class handler;
108class partition_info;
109enum enum_stats_auto_recalc : int;
110enum Value_generator_source : short;
111enum row_type : int;
112struct AccessPath;
113struct HA_CREATE_INFO;
114struct LEX;
115struct NESTED_JOIN;
117struct TABLE;
118struct TABLE_SHARE;
119struct handlerton;
121using plan_idx = int;
122
123namespace dd {
124class Table;
125class View;
126
127enum class enum_table_type;
128} // namespace dd
130
134
138
140
142
143enum class enum_json_diff_operation;
144
146
148
150
151#define store_record(A, B) \
152 memcpy((A)->B, (A)->record[0], (size_t)(A)->s->reclength)
153#define restore_record(A, B) \
154 memcpy((A)->record[0], (A)->B, (size_t)(A)->s->reclength)
155#define cmp_record(A, B) \
156 memcmp((A)->record[0], (A)->B, (size_t)(A)->s->reclength)
157
158#define tmp_file_prefix "#sql" /**< Prefix for tmp tables */
159#define tmp_file_prefix_length 4
160#define TMP_TABLE_KEY_EXTRA 8
161#define PLACEHOLDER_TABLE_ROW_ESTIMATE 2
162
163/**
164 Enumerate possible types of a table from re-execution
165 standpoint.
166 Table_ref class has a member of this type.
167 At prepared statement prepare, this member is assigned a value
168 as of the current state of the database. Before (re-)execution
169 of a prepared statement, we check that the value recorded at
170 prepare matches the type of the object we obtained from the
171 table definition cache.
172
173 @sa check_and_update_table_version()
174 @sa Execute_observer
175 @sa Prepared_statement::reprepare()
176*/
177
179 /** Initial value set by the parser */
186
187/**
188 Enumerate possible status of a identifier name while determining
189 its validity
190*/
192
193/*************************************************************************/
194
195/**
196 Object_creation_ctx -- interface for creation context of database objects
197 (views, stored routines, events, triggers). Creation context -- is a set
198 of attributes, that should be fixed at the creation time and then be used
199 each time the object is parsed or executed.
200*/
201
203 public:
205
206 void restore_env(THD *thd, Object_creation_ctx *backup_ctx);
207
208 protected:
210 virtual Object_creation_ctx *create_backup_ctx(THD *thd) const = 0;
211 virtual void delete_backup_ctx() = 0;
212
213 virtual void change_env(THD *thd) const = 0;
214
215 public:
216 virtual ~Object_creation_ctx() = default;
217};
218
219/*************************************************************************/
220
221/**
222 Default_object_creation_ctx -- default implementation of
223 Object_creation_ctx.
224*/
225
227 public:
229
231
232 protected:
234
236 const CHARSET_INFO *connection_cl);
237
238 protected:
239 Object_creation_ctx *create_backup_ctx(THD *thd) const override;
240 void delete_backup_ctx() override;
241
242 void change_env(THD *thd) const override;
243
244 protected:
245 /**
246 client_cs stores the value of character_set_client session variable.
247 The only character set attribute is used.
248
249 Client character set is included into query context, because we save
250 query in the original character set, which is client character set. So,
251 in order to parse the query properly we have to switch client character
252 set on parsing.
253 */
255
256 /**
257 connection_cl stores the value of collation_connection session
258 variable. Both character set and collation attributes are used.
259
260 Connection collation is included into query context, because it defines
261 the character set and collation of text literals in internal
262 representation of query (item-objects).
263 */
265};
266
267/**
268 View_creation_ctx -- creation context of view objects.
269*/
270
272 public:
273 static View_creation_ctx *create(THD *thd);
274
275 static View_creation_ctx *create(THD *thd, Table_ref *view);
276
277 private:
279};
280
281/*************************************************************************/
282
283/** Order clause list element */
284
286
287struct ORDER {
288 /// @returns true if item pointer is same as original
289 bool is_item_original() const { return item[0] == item_initial; }
290
291 ORDER *next{nullptr};
292
293 /**
294 If the query block includes non-primitive grouping, then these modifiers are
295 represented as grouping sets. The variable 'grouping_set_info' functions as
296 a bitvector, containing the grouping set details. If the 'ith' bit of the
297 variable is set, then the corresponding element is included in the 'ith'
298 grouping set. */
300 /**
301 The initial ordering expression. Usually substituted during resolving
302 and must not be used during optimization and execution.
303 */
304 Item *item_initial{nullptr}; /* Storage for initial item */
305
306 public:
307 /**
308 Points at the item in the select fields. Note that this means that
309 after resolving, it points into a slice (see JOIN::ref_items),
310 even though the item is not of type Item_ref!
311 */
313
315
317 ORDER_NOT_RELEVANT}; /* Requested direction of ordering */
318 bool in_field_list{false}; /* true if in select field list */
319 /**
320 Tells whether this ORDER element was referenced with an alias or with an
321 expression in the query, and what the alias was:
322 SELECT a AS foo GROUP BY foo: "foo".
323 SELECT a AS foo GROUP BY a: nullptr.
324 */
325 const char *used_alias{nullptr};
326 /**
327 When GROUP BY is implemented with a temporary table (i.e. the table takes
328 care to store only unique group rows, table->group != nullptr), each GROUP
329 BY expression is stored in a column of the table, which is
330 'field_in_tmp_table'.
331 Such field may point into table->record[0] (if we only use it to get its
332 value from a tmp table's row), or into 'buff' (if we use it to do index
333 lookup into the tmp table).
334 */
336 char *buff{nullptr}; /* If tmp-table group */
338 bool is_explicit{false}; /* Whether ASC/DESC is explicitly specified */
339};
340
341/**
342 State information for internal tables grants.
343 This structure is part of the Table_ref, and is updated
344 during the ACL check process.
345 @sa GRANT_INFO
346*/
348 /** True if the internal lookup by schema name was done. */
350 /** Cached internal schema access. */
352 /** True if the internal lookup by table name was done. */
354 /** Cached internal table access. */
356};
357
358/**
359 @brief The current state of the privilege checking process for the current
360 user, SQL statement and SQL object.
361
362 @details The privilege checking process is divided into phases depending on
363 the level of the privilege to be checked and the type of object to be
364 accessed. Due to the mentioned scattering of privilege checking
365 functionality, it is necessary to keep track of the state of the process.
366
367 A GRANT_INFO also serves as a cache of the privilege hash tables. Relevant
368 members are grant_table and version.
369 */
371 GRANT_INFO();
372 /**
373 @brief A copy of the privilege information regarding the current host,
374 database, object and user.
375
376 @details The version of this copy is found in GRANT_INFO::version.
377 */
379 /**
380 @brief Used for cache invalidation when caching privilege information.
381
382 @details The privilege information is stored on disk, with dedicated
383 caches residing in memory: table-level and column-level privileges,
384 respectively, have their own dedicated caches.
385
386 The GRANT_INFO works as a level 1 cache with this member updated to the
387 current value of the global variable @c grant_version (@c static variable
388 in sql_acl.cc). It is updated Whenever the GRANT_INFO is refreshed from
389 the level 2 cache. The level 2 cache is the @c column_priv_hash structure
390 (@c static variable in sql_acl.cc)
391
392 @see grant_version
393 */
394 uint version{0};
395 /**
396 @brief The set of privileges that the current user has fulfilled for a
397 certain host, database, and object.
398
399 @details This field is continually updated throughout the access checking
400 process. In each step the "wanted privilege" is checked against the
401 fulfilled privileges. When/if the intersection of these sets is empty,
402 access is granted.
403
404 The set is implemented as a bitmap, with the bits defined in sql_acl.h.
405 */
407 /** The grant state for internal tables. */
409};
410
418
419/**
420 Category of table found in the table share.
421*/
423 /**
424 Unknown value.
425 */
427
428 /**
429 Temporary table.
430 The table is visible only in the session.
431 Therefore,
432 - FLUSH TABLES WITH READ LOCK
433 - SET GLOBAL READ_ONLY = ON
434 do not apply to this table.
435 Note that LOCK TABLE t FOR READ/WRITE
436 can be used on temporary tables.
437 Temporary tables are not part of the table cache.
438
439 2016-06-14 Contrary to what's written in these comments, the truth is:
440 - tables created by CREATE TEMPORARY TABLE have TABLE_CATEGORY_USER
441 - tables created by create_tmp_table() (internal ones) have
442 TABLE_CATEGORY_TEMPORARY.
443 ha_innodb.cc relies on this observation (so: grep it). If you clean this
444 up, you may also want to look at 'no_tmp_table'; its enum values' meanings
445 have degraded over time: INTERNAL_TMP_TABLE is not used for some internal
446 tmp tables (derived tables). Unification of both enums would be
447 great. Whatever the result, we need to be able to distinguish the two
448 types of temporary tables above, as usage patterns are more restricted for
449 the second type, and allow more optimizations.
450 */
452
453 /**
454 User table.
455 These tables do honor:
456 - LOCK TABLE t FOR READ/WRITE
457 - FLUSH TABLES WITH READ LOCK
458 - SET GLOBAL READ_ONLY = ON
459 User tables are cached in the table cache.
460 */
462
463 /**
464 System table, maintained by the server.
465 These tables do honor:
466 - LOCK TABLE t FOR READ/WRITE
467 - FLUSH TABLES WITH READ LOCK
468 - SET GLOBAL READ_ONLY = ON
469 Typically, writes to system tables are performed by
470 the server implementation, not explicitly be a user.
471 System tables are cached in the table cache.
472 */
474
475 /**
476 Information schema tables.
477 These tables are an interface provided by the system
478 to inspect the system metadata.
479 These tables do *not* honor:
480 - LOCK TABLE t FOR READ/WRITE
481 - FLUSH TABLES WITH READ LOCK
482 - SET GLOBAL READ_ONLY = ON
483 as there is no point in locking explicitly
484 an INFORMATION_SCHEMA table.
485 Nothing is directly written to information schema tables.
486 Note that this value is not used currently,
487 since information schema tables are not shared,
488 but implemented as session specific temporary tables.
489 */
490 /*
491 TODO: Fixing the performance issues of I_S will lead
492 to I_S tables in the table cache, which should use
493 this table type.
494 */
496
497 /**
498 Log tables.
499 These tables are an interface provided by the system
500 to inspect the system logs.
501 These tables do *not* honor:
502 - LOCK TABLE t FOR READ/WRITE
503 - FLUSH TABLES WITH READ LOCK
504 - SET GLOBAL READ_ONLY = ON
505 as there is no point in locking explicitly
506 a LOG table.
507 An example of LOG tables are:
508 - mysql.slow_log
509 - mysql.general_log,
510 which *are* updated even when there is either
511 a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
512 User queries do not write directly to these tables
513 (there are exceptions for log tables).
514 The server implementation perform writes.
515 Log tables are cached in the table cache.
516 */
518
519 /**
520 Performance schema tables.
521 These tables are an interface provided by the system
522 to inspect the system performance data.
523 These tables do *not* honor:
524 - LOCK TABLE t FOR READ/WRITE
525 - FLUSH TABLES WITH READ LOCK
526 - SET GLOBAL READ_ONLY = ON
527 as there is no point in locking explicitly
528 a PERFORMANCE_SCHEMA table.
529 An example of PERFORMANCE_SCHEMA tables are:
530 - performance_schema.*
531 which *are* updated (but not using the handler interface)
532 even when there is either
533 a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
534 User queries do not write directly to these tables
535 (there are exceptions for SETUP_* tables).
536 The server implementation perform writes.
537 Performance tables are cached in the table cache.
538 */
540
541 /**
542 Replication Information Tables.
543 These tables are used to store replication information.
544 These tables do *not* honor:
545 - LOCK TABLE t FOR READ/WRITE
546 - FLUSH TABLES WITH READ LOCK
547 - SET GLOBAL READ_ONLY = ON
548 as there is no point in locking explicitly
549 a Replication Information table.
550 An example of replication tables are:
551 - mysql.slave_master_info
552 - mysql.slave_relay_log_info,
553 which *are* updated even when there is either
554 a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
555 User queries do not write directly to these tables.
556 Replication tables are cached in the table cache.
557 */
559
560 /**
561 Gtid Table.
562 The table is used to store gtids.
563 The table does *not* honor:
564 - LOCK TABLE t FOR READ/WRITE
565 - FLUSH TABLES WITH READ LOCK
566 - SET GLOBAL READ_ONLY = ON
567 as there is no point in locking explicitly
568 a Gtid table.
569 An example of gtid_executed table is:
570 - mysql.gtid_executed,
571 which is updated even when there is either
572 a GLOBAL READ LOCK or a GLOBAL READ_ONLY in effect.
573 Gtid table is cached in the table cache.
574 */
576
577 /**
578 A data dictionary table.
579 Table's with this category will skip checking the
580 TABLE_SHARE versions because these table structures
581 are fixed upon server bootstrap.
582 */
584
585 /**
586 A ACL metadata table.
587 For table in this category we will skip row locks when SQL statement
588 reads them.
589 */
593
594extern ulong refresh_version;
595
600};
601
603 uint count;
605};
606
608 protected:
610 virtual void report_error(uint code, const char *fmt, ...) = 0;
611
612 public:
614 virtual ~Table_check_intact() = default;
615
616 /**
617 Checks whether a table is intact. Should be done *just* after the table has
618 been opened.
619
620 @param[in] thd Thread handle
621 @param[in] table The table to check
622 @param[in] table_def Expected structure of the table (column name
623 and type)
624
625 @retval false OK
626 @retval true There was an error.
627 */
628 bool check(THD *thd, TABLE *table, const TABLE_FIELD_DEF *table_def);
629};
630
631/**
632 Class representing the fact that some thread waits for table
633 share to be flushed. Is used to represent information about
634 such waits in MDL deadlock detector.
635*/
636
641
642 public:
644 uint deadlock_weight_arg)
645 : m_ctx(ctx_arg),
646 m_share(share_arg),
647 m_deadlock_weight(deadlock_weight_arg) {}
648
649 MDL_context *get_ctx() const { return m_ctx; }
650
651 bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override;
652
653 uint get_deadlock_weight() const override;
654
655 /**
656 Pointers for participating in the list of waiters for table share.
657 */
660};
661
662typedef I_P_List<
667
671 /**
672 Name of unique key matching FK in parent table, "" if there is no
673 unique key.
674 */
678 /**
679 Arrays with names of referencing columns of the FK.
680 */
683
689
690/**
691 Definition of name for generated keys, owned by TABLE_SHARE
692*/
693struct Key_name {
695};
696
697/**
698 This structure is shared between different table objects. There is one
699 instance of table share per one table in the database.
700*/
701
703 TABLE_SHARE() = default;
704
705 /**
706 Create a new TABLE_SHARE with the given version number.
707 @param version the version of the TABLE_SHARE
708 @param secondary set to true if the TABLE_SHARE represents a table
709 in a secondary storage engine
710 */
711 TABLE_SHARE(unsigned long version, bool secondary)
712 : m_version(version), m_secondary_engine(secondary) {}
713
714 /*
715 Managed collection of refererence-counted snapshots of histograms statistics
716 for the table. TABLE objects acquire/release pointers to histogram
717 statistics from this collection. A new statistics snapshot is inserted when
718 the share is initialized and when histograms are updated/dropped.
719
720 For temporary tables m_histograms should be nullptr since we do not support
721 histograms on temporary tables.
722 */
724
725 /** Category of this table. */
727
729 /**
730 Used to allocate new handler for internal temporary table when the
731 size limitation of the primary storage engine is exceeded.
732 */
734
735 TYPELIB keynames; /* Pointers to keynames */
736 TYPELIB *intervals{nullptr}; /* pointer to interval info */
737 mysql_mutex_t LOCK_ha_data; /* To protect access to ha_data */
738 TABLE_SHARE *next{nullptr}, **prev{nullptr}; /* Link to unused shares */
739 /**
740 Array of table_cache_instances pointers to elements of table caches
741 respresenting this table in each of Table_cache instances.
742 Allocated along with the share itself in alloc_table_share().
743 Each element of the array is protected by Table_cache::m_lock in the
744 corresponding Table_cache. False sharing should not be a problem in
745 this case as elements of this array are supposed to be updated rarely.
746 */
748
749 /* The following is copied to each TABLE on OPEN */
750 Field **field{nullptr};
752 KEY *key_info{nullptr}; /* data of keys defined for the table */
753 uint *blob_field{nullptr}; /* Index to blobs in Field array */
754
755 uchar *default_values{nullptr}; /* row with default values */
756 LEX_STRING comment{nullptr, 0}; /* Comment about table */
757 LEX_STRING compress{nullptr, 0}; /* Compression algorithm */
758 LEX_STRING encrypt_type{nullptr, 0}; /* encryption algorithm */
759
760 /** Secondary storage engine. */
762 /** Secondary engine load status */
763 bool secondary_load{false};
764
766 nullptr}; /* Default charset of string fields */
767
769 /*
770 Key which is used for looking-up table in table cache and in the list
771 of thread's temporary tables. Has the form of:
772 "database_name\0table_name\0" + optional part for temporary tables.
773
774 Note that all three 'table_cache_key', 'db' and 'table_name' members
775 must be set (and be non-zero) for tables in table cache. They also
776 should correspond to each other.
777 To ensure this one can use set_table_cache() methods.
778 */
780 LEX_CSTRING db{nullptr, 0}; /* Pointer to db */
781 LEX_CSTRING table_name{nullptr, 0}; /* Table name (for open) */
782 LEX_STRING path{nullptr, 0}; /* Path to .frm file (from datadir) */
783 LEX_CSTRING normalized_path{nullptr, 0}; /* unpack_filename(path) */
785
788
789 /**
790 The set of indexes that are not disabled for this table. I.e. it excludes
791 indexes disabled by `ALTER TABLE ... DISABLE KEYS`, however it does
792 include invisible indexes. The data dictionary populates this bitmap.
793 */
795
796 /// The set of visible and enabled indexes for this table.
799 ha_rows min_rows{0}, max_rows{0}; /* create information */
800 ulong avg_row_length{0}; /* create information */
801 ulong mysql_version{0}; /* 0 if .frm is created before 5.0 */
802 ulong reclength{0}; /* Recordlength */
803 ulong stored_rec_length{0}; /* Stored record length
804 (no generated-only generated fields) */
806
807 plugin_ref db_plugin{nullptr}; /* storage engine plugin */
808 inline handlerton *db_type() const /* table_type for handler */
809 {
810 // assert(db_plugin);
811 return db_plugin ? plugin_data<handlerton *>(db_plugin) : nullptr;
812 }
813 /**
814 Value of ROW_FORMAT option for the table as provided by user.
815 Can be different from the real row format used by the storage
816 engine. ROW_TYPE_DEFAULT value indicates that no explicit
817 ROW_FORMAT was specified for the table. @sa real_row_type.
818 */
819 enum row_type row_type = {}; // Zero-initialized to ROW_TYPE_DEFAULT
820 /** Real row format used for the table by the storage engine. */
821 enum row_type real_row_type = {}; // Zero-initialized to ROW_TYPE_DEFAULT
823
824 /**
825 Only for internal temporary tables.
826 Count of TABLEs (having this TABLE_SHARE) which have a "handler"
827 (table->file!=nullptr) which is open (ha_open() has been called).
828 */
830
831 /**
832 Only for internal temporary tables.
833 Count of TABLEs (having this TABLE_SHARE) which have opened this table.
834 */
836
837 // Can only be 1,2,4,8 or 16, but use uint32_t since that how it is
838 // represented in InnoDB
839 std::uint32_t key_block_size{0}; /* create key_block_size, if used */
840 uint stats_sample_pages{0}; /* number of pages to sample during
841 stats estimation, if used, otherwise 0. */
843 stats_auto_recalc{}; /* Automatic recalc of stats.
844 Zero-initialized to HA_STATS_AUTO_RECALC_DEFAULT
845 */
847 uint fields{0}; /* Number of fields */
848 uint rec_buff_length{0}; /* Size of table->record[] buffer */
849 uint keys{0}; /* Number of keys defined for the table*/
850 uint key_parts{0}; /* Number of key parts of all keys
851 defined for the table
852 */
853 uint max_key_length{0}; /* Length of the longest key */
854 uint max_unique_length{0}; /* Length of the longest unique key */
856 /**
857 Whether this is a temporary table that already has a UNIQUE index (removing
858 duplicate rows on insert), so that the optimizer does not need to run
859 DISTINCT itself. Also used for INTERSECT and EXCEPT as a fall-back if
860 hashing fails (secondary overflow of in-memory hash table, in which case
861 we revert to de-duplication using the unique key in the output table).
862 */
863 bool is_distinct{false};
864
865 uint null_fields{0}; /* number of null fields */
866 uint blob_fields{0}; /* number of blob fields */
867 uint varchar_fields{0}; /* number of varchar fields */
868 /**
869 For materialized derived tables; @see add_derived_key().
870 'first' means: having the lowest position in key_info.
871 */
873 /**
874 For materialized derived tables: allocated size of key_info array.
875 */
877 /**
878 For materialized derived tables: allocated size of base_key_parts array of
879 all TABLE objects. Used for generated keys.
880 */
882 /**
883 Array of names for generated keys, used for materialized derived tables.
884 Shared among all TABLE objects referring to this table share.
885 */
887 /**
888 Records per key array, used for materialized derived tables.
889 This is a contiguous array, with size given by max_tmp_key_parts.
890 The array is shared with all TABLE objects referring to this table share.
891 */
892 ulong *base_rec_per_key{nullptr};
893 /**
894 Records per key array, float rep., used for materialized derived tables.
895 This is a contiguous array, with size given by max_tmp_key_parts.
896 The array is shared with all TABLE objects referring to this table share.
897 */
899 /**
900 Bitmap with flags representing some of table options/attributes.
901
902 @sa HA_OPTION_PACK_RECORD, HA_OPTION_PACK_KEYS, ...
903
904 @note This is basically copy of HA_CREATE_INFO::table_options bitmap
905 at the time of table opening/usage.
906 */
908 /**
909 Bitmap with flags representing some of table options/attributes which
910 are in use by storage engine.
911
912 @note db_options_in_use is normally copy of db_create_options but can
913 be overridden by SE. E.g. MyISAM does this at handler::open() and
914 handler::info() time.
915 */
917 uint rowid_field_offset{0}; /* Field_nr +1 to rowid field */
918 /* Primary key index number, used in TABLE::key_info[] */
919 uint primary_key{0};
920 uint next_number_index{0}; /* autoincrement key number */
921 uint next_number_key_offset{0}; /* autoinc keypart offset in a key */
922 uint next_number_keypart{0}; /* autoinc keypart number in a key */
923 bool error{false}; /* error during open_table_def() */
925 /// Number of generated fields
926 uint vfields{0};
927 /// Number of fields having the default value generated
929 bool system{false}; /* Set if system table (one record) */
930 bool db_low_byte_first{false}; /* Portable row format */
931 bool crashed{false};
932 bool is_view{false};
933 bool m_open_in_progress{false}; /* True: alloc'ed, false: def opened */
934 mysql::binlog::event::Table_id table_map_id; /* for row-based replication */
935
936 /*
937 Cache for row-based replication table share checks that does not
938 need to be repeated. Possible values are: -1 when cache value is
939 not calculated yet, 0 when table *shall not* be replicated, 1 when
940 table *may* be replicated.
941 */
943
944 /*
945 Storage media to use for this table (unless another storage
946 media has been specified on an individual column - in versions
947 where that is supported)
948 */
950
951 /* Name of the tablespace used for this table */
952 const char *tablespace{nullptr};
953
954 /**
955 Partition meta data. Allocated from TABLE_SHARE::mem_root,
956 created when reading from the dd tables,
957 used as template for each TABLE instance.
958 The reason for having it on the TABLE_SHARE is to be able to reuse the
959 partition_elements containing partition names, values etc. instead of
960 allocating them for each TABLE instance.
961 TODO: Currently it is filled in and then only used for generating
962 the partition_info_str. The plan is to clone/copy/reference each
963 TABLE::part_info instance from it.
964 What is missing before it can be completed:
965 1) The partition expression, currently created only during parsing which
966 also needs the current TABLE instance as context for name resolution etc.
967 2) The partition values, currently the DD stores them as text so it needs
968 to be converted to field images (which is now done by first parsing the
969 value text into an Item, then saving the Item result/value into a field
970 and then finally copy the field image).
971 */
973 // TODO: Remove these four variables:
974 /**
975 Filled in when reading from frm.
976 This can simply be removed when removing the .frm support,
977 since it is already stored in the new DD.
978 */
979 bool auto_partitioned{false};
980 /**
981 Storing the full partitioning clause (PARTITION BY ...) which is used
982 when creating new partition_info object for each new TABLE object by
983 parsing this string.
984 These two will be needed until the missing parts above is fixed.
985 */
986 char *partition_info_str{nullptr};
988
989 /**
990 Cache the checked structure of this table.
991
992 The pointer data is used to describe the structure that
993 a instance of the table must have. Each element of the
994 array specifies a field that must exist on the table.
995
996 The pointer is cached in order to perform the check only
997 once -- when the table is loaded from the disk.
998 */
1000
1001 /** Main handler's share */
1003
1004 /** Instrumentation for this table share. */
1006
1007 /**
1008 List of tickets representing threads waiting for the share to be flushed.
1009 */
1011
1012 /**
1013 View object holding view definition read from DD. This object is not
1014 cached, and is owned by the table share. We are not able to read it
1015 on demand since we may then get a cache miss while holding LOCK_OPEN.
1016 */
1017 const dd::View *view_object{nullptr};
1018
1019 /**
1020 Data-dictionary object describing explicit temporary table represented
1021 by this share. NULL for other table types (non-temporary tables, internal
1022 temporary tables). This object is owned by TABLE_SHARE and should be
1023 deleted along with it.
1024 */
1026
1027 /// For materialized derived tables; @see add_derived_key().
1029
1030 /**
1031 Arrays with descriptions of foreign keys in which this table participates
1032 as child or parent. We only cache in them information from dd::Table object
1033 which is sufficient for use by prelocking algorithm/to check if table is
1034 referenced by a foreign key.
1035 */
1040
1041 // List of check constraint share instances.
1043
1044 /**
1045 Schema's read only mode - ON (true) or OFF (false). This is filled in
1046 when the share is initialized with meta data from DD. If the schema is
1047 altered, the tables and share are removed. This can be done since
1048 ALTER SCHEMA acquires exclusive meta data locks on the tables in the
1049 schema. We set this only for non-temporary tables. Otherwise, the value
1050 of the member below is 'NOT_SET'.
1051 */
1054
1055 /**
1056 Set share's table cache key and update its db and table name appropriately.
1057
1058 @param key_buff Buffer with already built table cache key to be
1059 referenced from share.
1060 @param key_length Key length.
1061
1062 @note
1063 Since 'key_buff' buffer will be referenced from share it should has same
1064 life-time as share itself.
1065 This method automatically ensures that TABLE_SHARE::table_name/db have
1066 appropriate values by using table cache key as their source.
1067 */
1068
1069 void set_table_cache_key(char *key_buff, size_t key_length) {
1070 table_cache_key.str = key_buff;
1071 table_cache_key.length = key_length;
1072 /*
1073 Let us use the fact that the key is "db/0/table_name/0" + optional
1074 part for temporary tables.
1075 */
1077 db.length = strlen(db.str);
1078 table_name.str = db.str + db.length + 1;
1079 table_name.length = strlen(table_name.str);
1080 }
1081
1082 /**
1083 Set share's table cache key and update its db and table name appropriately.
1084
1085 @param key_buff Buffer to be used as storage for table cache key
1086 (should be at least key_length bytes).
1087 @param key Value for table cache key.
1088 @param key_length Key length.
1089
1090 NOTE
1091 Since 'key_buff' buffer will be used as storage for table cache key
1092 it should has same life-time as share itself.
1093 */
1094
1095 void set_table_cache_key(char *key_buff, const char *key, size_t key_length) {
1096 memcpy(key_buff, key, key_length);
1097 set_table_cache_key(key_buff, key_length);
1098 }
1099
1101
1102 /** Returns the version of this TABLE_SHARE. */
1103 unsigned long version() const { return m_version; }
1104
1105 /**
1106 Set the version of this TABLE_SHARE to zero. This marks the
1107 TABLE_SHARE for automatic removal from the table definition cache
1108 once it is no longer referenced.
1109 */
1110 void clear_version();
1111
1112 /** Is this table share being expelled from the table definition cache? */
1113 bool has_old_version() const { return version() != refresh_version; }
1114
1115 /**
1116 Convert unrelated members of TABLE_SHARE to one enum
1117 representing its type.
1118
1119 @todo perhaps we need to have a member instead of a function.
1120 */
1122 if (is_view) return TABLE_REF_VIEW;
1123 switch (tmp_table) {
1124 case NO_TMP_TABLE:
1125 return TABLE_REF_BASE_TABLE;
1126 case SYSTEM_TMP_TABLE:
1127 return TABLE_REF_I_S_TABLE;
1128 default:
1129 return TABLE_REF_TMP_TABLE;
1130 }
1131 }
1132 /**
1133 Return a table metadata version.
1134 * for base tables and views, we return table_map_id.
1135 It is assigned from a global counter incremented for each
1136 new table loaded into the table definition cache (TDC).
1137 * for temporary tables it's table_map_id again. But for
1138 temporary tables table_map_id is assigned from
1139 thd->query_id. The latter is assigned from a thread local
1140 counter incremented for every new SQL statement. Since
1141 temporary tables are thread-local, each temporary table
1142 gets a unique id.
1143 * for everything else (e.g. information schema tables),
1144 the version id is zero.
1145
1146 This choice of version id is a large compromise
1147 to have a working prepared statement validation in 5.1. In
1148 future version ids will be persistent, as described in WL#4180.
1149
1150 Let's try to explain why and how this limited solution allows
1151 to validate prepared statements.
1152
1153 Firstly, sets (in mathematical sense) of version numbers
1154 never intersect for different table types. Therefore,
1155 version id of a temporary table is never compared with
1156 a version id of a view, and vice versa.
1157
1158 Secondly, for base tables and views, we know that each DDL flushes
1159 the respective share from the TDC. This ensures that whenever
1160 a table is altered or dropped and recreated, it gets a new
1161 version id.
1162 Unfortunately, since elements of the TDC are also flushed on
1163 LRU basis, this choice of version ids leads to false positives.
1164 E.g. when the TDC size is too small, we may have a SELECT
1165 * FROM INFORMATION_SCHEMA.TABLES flush all its elements, which
1166 in turn will lead to a validation error and a subsequent
1167 reprepare of all prepared statements. This is
1168 considered acceptable, since as long as prepared statements are
1169 automatically reprepared, spurious invalidation is only
1170 a performance hit. Besides, no better simple solution exists.
1171
1172 For temporary tables, using thd->query_id ensures that if
1173 a temporary table was altered or recreated, a new version id is
1174 assigned. This suits validation needs very well and will perhaps
1175 never change.
1176
1177 Metadata of information schema tables never changes.
1178 Thus we can safely assume 0 for a good enough version id.
1179
1180 Finally, by taking into account table type, we always
1181 track that a change has taken place when a view is replaced
1182 with a base table, a base table is replaced with a temporary
1183 table and so on.
1184
1185 @retval 0 For schema tables, DD tables and system views.
1186 non-0 For bases tables, views and temporary tables.
1187
1188 @sa Table_ref::is_table_ref_id_equal()
1189 */
1191
1192 /** Determine if the table is missing a PRIMARY KEY. */
1194 assert(primary_key <= MAX_KEY);
1195 return primary_key == MAX_KEY;
1196 }
1197
1198 uint find_first_unused_tmp_key(const Key_map &k);
1199
1200 bool visit_subgraph(Wait_for_flush *waiting_ticket,
1201 MDL_wait_for_graph_visitor *gvisitor);
1202
1203 bool wait_for_old_version(THD *thd, struct timespec *abstime,
1204 uint deadlock_weight);
1205
1206 /**
1207 The set of indexes that the optimizer may use when creating an execution
1208 plan.
1209 */
1210 Key_map usable_indexes(const THD *thd) const;
1211
1212 /** Release resources and free memory occupied by the table share. */
1213 void destroy();
1214
1215 /**
1216 How many TABLE objects use this TABLE_SHARE.
1217 @return the reference count
1218 */
1219 unsigned int ref_count() const {
1220 assert(assert_ref_count_is_locked(this));
1221 return m_ref_count;
1222 }
1223
1224 /**
1225 Increment the reference count by one.
1226 @return the new reference count
1227 */
1228 unsigned int increment_ref_count() {
1229 assert(assert_ref_count_is_locked(this));
1230 assert(!m_open_in_progress);
1231 return ++m_ref_count;
1232 }
1233
1234 /**
1235 Decrement the reference count by one.
1236 @return the new reference count
1237 */
1238 unsigned int decrement_ref_count() {
1239 assert(assert_ref_count_is_locked(this));
1240 assert(!m_open_in_progress);
1241 assert(m_ref_count > 0);
1242 return --m_ref_count;
1243 }
1244
1245 /// Does this TABLE_SHARE represent a table in a primary storage engine?
1246 bool is_primary_engine() const { return !m_secondary_engine; }
1247
1248 /// Does this TABLE_SHARE represent a table in a secondary storage engine?
1250
1251 /**
1252 Does this TABLE_SHARE represent a primary table that has a shadow
1253 copy in a secondary storage engine?
1254 */
1256 return is_primary_engine() && secondary_engine.str != nullptr;
1257 }
1258
1259 /** Returns whether this table is referenced by a foreign key. */
1261
1262 private:
1263 /// How many TABLE objects use this TABLE_SHARE.
1264 unsigned int m_ref_count{0};
1265
1266 /**
1267 TABLE_SHARE version, if changed the TABLE_SHARE must be reopened.
1268 NOTE: The TABLE_SHARE will not be reopened during LOCK TABLES in
1269 close_thread_tables!!!
1270 */
1271 unsigned long m_version{0};
1272
1273 protected: // To allow access from unit tests.
1274 /// Does this TABLE_SHARE represent a table in a secondary storage engine?
1276};
1277
1278/**
1279 Class is used as a BLOB field value storage for
1280 intermediate GROUP_CONCAT results. Used only for
1281 GROUP_CONCAT with DISTINCT or ORDER BY options.
1282 */
1283
1285 private:
1287 /**
1288 Sign that some values were cut
1289 during saving into the storage.
1290 */
1292
1293 public:
1296
1297 void reset() {
1299 truncated_value = false;
1300 }
1301 /**
1302 Function creates duplicate of 'from'
1303 string in 'storage' MEM_ROOT.
1304
1305 @param from string to copy
1306 @param length string length
1307
1308 @retval Pointer to the copied string.
1309 @retval 0 if an error occurred.
1310 */
1311 char *store(const char *from, size_t length) {
1312 return (char *)memdup_root(&storage, from, length);
1313 }
1316 }
1317 bool is_truncated_value() const { return truncated_value; }
1318};
1319
1320/**
1321 Class that represents a single change to a column value in partial
1322 update of a JSON column.
1323*/
1324class Binary_diff final {
1325 /// The offset of the start of the change.
1326 size_t m_offset;
1327
1328 /// The size of the portion that is to be replaced.
1329 size_t m_length;
1330
1331 public:
1332 /**
1333 Create a new Binary_diff object.
1334
1335 @param offset the offset of the beginning of the change
1336 @param length the length of the section that is to be replaced
1337 */
1338 Binary_diff(size_t offset, size_t length)
1340
1341 /// @return the offset of the changed data
1342 size_t offset() const { return m_offset; }
1343
1344 /// @return the length of the changed data
1345 size_t length() const { return m_length; }
1346
1347 /**
1348 Get a pointer to the start of the replacement data.
1349
1350 @param field the column that is updated
1351 @return a pointer to the start of the replacement data
1352 */
1353 const char *new_data(const Field *field) const;
1354
1355 /**
1356 Get a pointer to the start of the old data to be replaced.
1357
1358 @param field the column that is updated
1359 @return a pointer to the start of old data to be replaced.
1360 */
1361 const char *old_data(const Field *field) const;
1362};
1363
1364/**
1365 Vector of Binary_diff objects.
1366
1367 The Binary_diff objects in the vector should be ordered on offset, and none
1368 of the diffs should be overlapping or adjacent.
1369*/
1371
1372/**
1373 Flags for TABLE::m_status (maximum 8 bits).
1374 The flags define the state of the row buffer in TABLE::record[0].
1375*/
1376/**
1377 STATUS_NOT_STARTED is set when table is not accessed yet.
1378 Neither STATUS_NOT_FOUND nor STATUS_NULL_ROW can be set when this flag is set.
1379*/
1380#define STATUS_NOT_STARTED 1
1381/**
1382 Means we were searching for a row and didn't find it. This is used by
1383 storage engines (@see handler::index_read_map()) and the executor, both
1384 when doing an exact row lookup and advancing a scan (no more rows in range).
1385*/
1386#define STATUS_NOT_FOUND 2
1387/// Reserved for use by multi-table update. Means the row has been updated.
1388#define STATUS_UPDATED 16
1389/**
1390 Means that table->null_row is set. This is an artificial NULL-filled row
1391 (one example: in outer join, if no match has been found in inner table).
1392*/
1393#define STATUS_NULL_ROW 32
1394/// Reserved for use by multi-table delete. Means the row has been deleted.
1395#define STATUS_DELETED 64
1396
1397/* Information for one open table */
1399
1400/* Bitmap of table's fields */
1402
1403/*
1404 NOTE: Despite being a struct (for historical reasons), TABLE has
1405 a nontrivial destructor.
1406*/
1407struct TABLE {
1408 TABLE_SHARE *s{nullptr};
1409 handler *file{nullptr};
1410 TABLE *next{nullptr}, *prev{nullptr};
1411
1412 private:
1413 /**
1414 Links for the lists of used/unused TABLE objects for the particular
1415 table in the specific instance of Table_cache (in other words for
1416 specific Table_cache_element object).
1417 Declared as private to avoid direct manipulation with those objects.
1418 One should use methods of I_P_List template instead.
1419 */
1420 TABLE *cache_next{nullptr}, **cache_prev{nullptr};
1421
1422 /*
1423 Give Table_cache_element access to the above two members to allow
1424 using them for linking TABLE objects in a list.
1425 */
1427
1428 public:
1429 // Pointer to the histograms available on the table.
1430 // Protected in the same way as the pointer to the share.
1432
1433 /**
1434 A bitmap marking the hidden generated columns that exists for functional
1435 indexes.
1436 */
1438 /**
1439 The current session using this table object.
1440 Should be NULL when object is not in use.
1441 For an internal temporary table, it is NULL when the table is closed.
1442 Used for two purposes:
1443 - Signal that the object is in use, and by which session.
1444 - Pass the thread handler to storage handlers.
1445 The field should NOT be used as a general THD reference, instead use
1446 a passed THD reference, or, if there is no such, current_thd.
1447 The reason for this is that we cannot guarantee the field is not NULL.
1448 */
1449 THD *in_use{nullptr};
1450 Field **field{nullptr}; /* Pointer to fields */
1451 /// Count of hidden fields, if internal temporary table; 0 otherwise.
1453
1454 uchar *record[2]{nullptr, nullptr}; /* Pointer to records */
1455 uchar *write_row_record{nullptr}; /* Used as optimisation in
1456 THD::write_row */
1457 uchar *insert_values{nullptr}; /* used by INSERT ... UPDATE */
1458
1459 /// Buffer for use in multi-row reads. Initially empty.
1461
1462 /*
1463 Map of keys that can be used to retrieve all data from this table
1464 needed by the query without reading the row.
1465 */
1468
1469 /* Merge keys are all keys that had a column referred to in the query */
1471
1472 /*
1473 possible_quick_keys is a superset of quick_keys to use with EXPLAIN of
1474 JOIN-less commands (single-table UPDATE and DELETE).
1475
1476 When explaining regular JOINs, we use JOIN_TAB::keys to output the
1477 "possible_keys" column value. However, it is not available for
1478 single-table UPDATE and DELETE commands, since they don't use JOIN
1479 optimizer at the top level. OTOH they directly use the range optimizer,
1480 that collects all keys usable for range access here.
1481 */
1483
1484 /*
1485 A set of keys that can be used in the query that references this
1486 table.
1487
1488 All indexes disabled on the table's TABLE_SHARE (see TABLE::s) will be
1489 subtracted from this set upon instantiation. Thus for any TABLE t it holds
1490 that t.keys_in_use_for_query is a subset of t.s.keys_in_use. Generally we
1491 must not introduce any new keys here (see setup_tables).
1492
1493 The set is implemented as a bitmap.
1494 */
1496 /* Map of keys that can be used to calculate GROUP BY without sorting */
1498 /* Map of keys that can be used to calculate ORDER BY without sorting */
1500 KEY *key_info{nullptr}; /* data of keys defined for the table */
1501 /**
1502 Key part array for generated keys, used for materialized derived tables.
1503 This is a contiguous array, with size given by s->max_tmp_key_parts.
1504 */
1506
1507 Field *next_number_field{nullptr}; /* Set if next_number is activated */
1508 Field *found_next_number_field{nullptr}; /* Set on open */
1509 /// Pointer to generated columns
1510 Field **vfield{nullptr};
1511 /// Pointer to fields having the default value generated
1513 /// Field used by unique constraint
1515 // ----------------------------------------------------------------------
1516 // The next few members are used if this (temporary) file is used solely for
1517 // the materialization/computation of an INTERSECT or EXCEPT set operation
1518 // (in addition to hash_field above used to detect duplicate rows). For
1519 // INTERSECT and EXCEPT, we always use the hash field and compute the shape
1520 // of the result set using m_set_counter. The latter is a hidden field
1521 // located between the hash field and the row proper, only present for
1522 // INTERSECT or EXCEPT materialized in a temporary result table. The
1523 // materialized table has no duplicate rows, relying instead of the embedded
1524 // counter to produce the correct number of duplicates with ALL semantics. If
1525 // we have distinct semantics, we squash duplicates. This all happens in the
1526 // reading step of the tmp table (TableScanIterator::Read),
1527 // cf. m_last_operation_is_distinct. For explanation if the logic of the set
1528 // counter, see MaterializeIterator<Profiler>::MaterializeOperand.
1529 //
1530
1531 /// A priori unlimited. We pass this on to TableScanIterator at construction
1532 /// time, q.v., to limit the number of rows out of an EXCEPT or INTERSECT.
1533 /// For these set operations, we do not know enough to enforce the limit at
1534 /// materialize time (as for UNION): only when reading the rows with
1535 /// TableScanIterator do we check the counters.
1536 /// @todo: Ideally, this limit should be communicated to TableScanIterator in
1537 /// some other way.
1539
1540 private:
1541 /// The set counter. It points to the field in the materialized table
1542 /// holding the counter used to compute INTERSECT and EXCEPT, in record[0].
1543 /// For EXCEPT [DISTINCT | ALL] and INTERSECT DISTINCT this is a simple 64
1544 /// bits counter. For INTERSECT ALL, it is subdivided into two sub counters
1545 /// cf. class HalfCounter, cf. MaterializeOperand. See set_counter().
1547
1548 /// If m_set_counter is set: true if last block has DISTINCT semantics,
1549 /// either because it is marked as such, or because we have computed this
1550 /// to give an equivalent answer. If false, we have ALL semantics.
1551 /// It will be true if any DISTINCT is given in the merged N-ary set
1552 /// operation. See is_distinct().
1554 /// If false, any de-duplication happens via an index on this table
1555 /// (e.g. SELECT DISTINCT, set operation). If true, this table represents the
1556 /// output of a set operation, and de-duplication happens via an in-memory
1557 /// hash map, in which case we do not use any index, unless we get secondary
1558 /// overflow.
1560
1561 public:
1571
1572 private:
1573 /// Holds the set operation type
1575
1576 public:
1577 /// Test if this tmp table stores the result of a UNION set operation or
1578 /// a single table.
1579 /// @return true if so, else false.
1580 bool is_union_or_table() const { return m_set_counter == nullptr; }
1581
1582 void set_use_hash_map(bool use_hash_map) {
1583 m_deduplicate_with_hash_map = use_hash_map;
1584 }
1585
1587
1588 /// Returns the set operation type
1590 if (m_set_op_type == SOT_NONE) {
1591 assert(is_union_or_table()); // EXCEPT and INTERSECT are already set up
1593 }
1594 return m_set_op_type;
1595 }
1596
1597 bool is_intersect() const {
1598 return m_set_op_type == SOT_INTERSECT_ALL ||
1600 }
1601
1602 bool is_except() const {
1603 return m_set_op_type == SOT_EXCEPT_ALL ||
1605 }
1606
1608 /**
1609 Initialize the set counter field pointer and the type of set operation
1610 *other than UNION*.
1611 @param set_counter the field in the materialized table that holds the
1612 counter we use to compute intersect or except
1613 @param except if true, EXCEPT, else INTERSECT
1614 @param distinct if true, the set operation is DISTINCT, else ALL
1615 */
1616 void set_set_op(Field_longlong *set_counter, bool except, bool distinct) {
1619 assert(m_set_op_type == SOT_NONE);
1620 m_set_op_type = except ? (distinct ? SOT_EXCEPT_DISTINCT : SOT_EXCEPT_ALL)
1621 : distinct ? SOT_INTERSECT_DISTINCT
1623 }
1624
1626 //
1627 // end of INTERSECT and EXCEPT specific members
1628 // ----------------------------------------------------------------------
1629
1630 Field *fts_doc_id_field{nullptr}; /* Set if FTS_DOC_ID field is present */
1631
1632 /* Table's triggers, 0 if there are no of them */
1634 Table_ref *pos_in_table_list{nullptr}; /* Element referring to this table */
1635 /* Position in thd->locked_table_list under LOCK TABLES */
1637 ORDER *group{nullptr};
1638 const char *alias{nullptr}; ///< alias or table name
1639 uchar *null_flags{nullptr}; ///< Pointer to the null flags of record[0]
1641 nullptr}; ///< Saved null_flags while null_row is true
1642
1643 /* containers */
1645 /*
1646 Bitmap of fields that one or more query condition refers to. Only
1647 used if optimizer_condition_fanout_filter is turned 'on'.
1648 Currently, only the WHERE clause and ON clause of inner joins is
1649 taken into account but not ON conditions of outer joins.
1650 Furthermore, HAVING conditions apply to groups and are therefore
1651 not useful as table condition filters.
1652 */
1654
1655 /**
1656 Bitmap of table fields (columns), which are explicitly set in the
1657 INSERT INTO statement. It is declared here to avoid memory allocation
1658 on MEM_ROOT).
1659
1660 @sa fields_set_during_insert.
1661 */
1663
1664 /**
1665 The read set contains the set of columns that the execution engine needs to
1666 process the query. In particular, it is used to tell the storage engine
1667 which columns are needed. For virtual generated columns, the underlying base
1668 columns are also added, since they are required in order to calculate the
1669 virtual generated columns.
1670
1671 Internal operations in the execution engine that need to move rows between
1672 buffers, such as aggregation, sorting, hash join and set operations, should
1673 rather use read_set_internal, since the virtual generated columns have
1674 already been calculated when the row was read from the storage engine.
1675
1676 Set during resolving; every field that gets resolved, sets its own bit
1677 in the read set. In some cases, we switch the read set around during
1678 various phases; note that it is a pointer.
1679
1680 In addition, for binary logging purposes, the bitmaps are set according
1681 to the settings of @@binlog_row_image. Therefore, for logging purposes,
1682 some additional fields, to those specified by the optimizer, may be
1683 flagged in the read and write sets.
1684 @c TABLE::mark_columns_per_binlog_row_image for additional details.
1685 */
1687
1689
1690 /**
1691 A bitmap of fields that are explicitly referenced by the query. This is
1692 mostly the same as read_set, but it does not include base columns of
1693 referenced virtual generated columns unless the base columns are referenced
1694 explicitly in the query.
1695
1696 This is the read set that should be used for determining which columns to
1697 store in join buffers, aggregation buffers, sort buffers, or similar
1698 operations internal to the execution engine. Both because it is unnecessary
1699 to store the implicitly read base columns in the buffer, since they won't
1700 ever be read out of the buffer anyways, and because the base columns may not
1701 even be possible to read, if a covering index scan is used and the index
1702 only contains the virtual column and not all its base columns.
1703 */
1705
1706 /**
1707 A pointer to the bitmap of table fields (columns), which are explicitly set
1708 in the INSERT INTO statement.
1709
1710 fields_set_during_insert points to def_fields_set_during_insert
1711 for base (non-temporary) tables. In other cases, it is NULL.
1712 Triggers can not be defined for temporary tables, so this bitmap does not
1713 matter for temporary tables.
1714
1715 @sa def_fields_set_during_insert.
1716 */
1718
1719 /*
1720 The ID of the query that opened and is using this table. Has different
1721 meanings depending on the table type.
1722
1723 Temporary tables:
1724
1725 table->query_id is set to thd->query_id for the duration of a statement
1726 and is reset to 0 once it is closed by the same statement. A non-zero
1727 table->query_id means that a statement is using the table even if it's
1728 not the current statement (table is in use by some outer statement).
1729
1730 Non-temporary tables:
1731
1732 Under pre-locked or LOCK TABLES mode: query_id is set to thd->query_id
1733 for the duration of a statement and is reset to 0 once it is closed by
1734 the same statement. A non-zero query_id is used to control which tables
1735 in the list of pre-opened and locked tables are actually being used.
1736 */
1738
1739 /*
1740 For each key that has quick_keys.is_set(key) == true: estimate of #records
1741 and max #key parts that range access would use.
1742 */
1744
1745 /* Bitmaps of key parts that =const for the entire join. */
1747
1750
1751 /*
1752 Estimate of number of records that satisfy SARGable part of the table
1753 condition, or table->file->records if no SARGable condition could be
1754 constructed.
1755 This value is used by join optimizer as an estimate of number of records
1756 that will pass the table condition (condition that depends on fields of
1757 this table and constants)
1758 */
1760
1761 uint lock_position{0}; /* Position in MYSQL_LOCK.table */
1762 uint lock_data_start{0}; /* Start pos. in MYSQL_LOCK.locks */
1763 uint lock_count{0}; /* Number of locks */
1764 uint db_stat{0}; /* mode of file as in handler.h */
1765 int current_lock{0}; /* Type of lock on table */
1766
1767 // List of table check constraints.
1769
1770 private:
1771 /**
1772 If true, this table is inner w.r.t. some outer join operation, all columns
1773 are nullable (in the query), and null_row may be true.
1774 */
1775 bool nullable{false};
1776
1777 uint8 m_status{0}; /* What's in record[0] */
1778 public:
1779 /*
1780 If true, the current table row is considered to have all columns set to
1781 NULL, including columns declared as "not null" (see nullable).
1782 @todo make it private, currently join buffering changes it through a pointer
1783 */
1784 bool null_row{false};
1785
1786 bool copy_blobs{false}; /* copy_blobs when storing */
1787
1788 /*
1789 TODO: Each of the following flags take up 8 bits. They can just as easily
1790 be put into one single unsigned long and instead of taking up 18
1791 bytes, it would take up 4.
1792 */
1793 bool force_index{false};
1794
1795 /**
1796 Flag set when the statement contains FORCE INDEX FOR ORDER BY
1797 See Table_ref::process_index_hints().
1798 */
1800
1801 /**
1802 Flag set when the statement contains FORCE INDEX FOR GROUP BY
1803 See Table_ref::process_index_hints().
1804 */
1806 bool const_table{false};
1807 /// True if writes to this table should not write rows and just write keys.
1808 bool no_rows{false};
1809
1810 /**
1811 If set, the optimizer has found that row retrieval should access index
1812 tree only.
1813 */
1814 bool key_read{false};
1815 /**
1816 Certain statements which need the full row, set this to ban index-only
1817 access.
1818 */
1819 bool no_keyread{false};
1820 /**
1821 If set, indicate that the table is not replicated by the server.
1822 */
1823 bool no_replicate{false};
1824 /* To signal that the table is associated with a HANDLER statement */
1825 bool open_by_handler{false};
1826 /**
1827 To indicate that value of the auto_increment field was provided
1828 explicitly by the user or from some other source (e.g. in case of
1829 INSERT ... SELECT, ALTER TABLE or LOAD DATA) and not as default
1830 or result of conversion from NULL value.
1831
1832 @note Since auto_increment fields are always non-NULL we can't find
1833 out using methods of Field class if 0 value stored in such field
1834 was provided explicitly or is result of applying default/conversion
1835 from NULL value. In the former case no new auto_increment value
1836 needs to be generated in MODE_NO_AUTO_VALUE_ON_ZERO mode, while
1837 the latter cases require new value generation. Hence the need
1838 for this flag.
1839 @note Used only in the MODE_NO_AUTO_VALUE_ON_ZERO mode and only
1840 by handler::write_row().
1841 */
1843 bool alias_name_used{false}; /* true if table_name is alias */
1844 bool get_fields_in_item_tree{false}; /* Signal to fix_field */
1845
1846 private:
1847 /**
1848 This TABLE object is invalid and cannot be reused. TABLE object might have
1849 inconsistent info or handler might not allow some operations.
1850
1851 For example, TABLE might have inconsistent info about partitioning.
1852 We also use this flag to avoid calling handler::reset() for partitioned
1853 InnoDB tables after in-place ALTER TABLE API commit phase and to force
1854 closing table after REPAIR TABLE has failed during its prepare phase as
1855 well.
1856
1857 @note This member can be set only by thread that owns/has opened the
1858 table and while holding its THD::LOCK_thd_data lock.
1859 It can be read without locking by this owner thread, or by some other
1860 thread concurrently after acquiring owner's THD::LOCK_thd_data.
1861
1862 @note The TABLE will not be reopened under LOCK TABLES in
1863 close_thread_tables().
1864 */
1865 bool m_invalid_dict{false};
1866
1867 /**
1868 This TABLE object is invalid and cannot be reused as it has outdated
1869 rec_per_key and handler stats.
1870
1871 @note This member is protected from concurrent access to it by lock of
1872 Table Cache's partition to which this TABLE object belongs,
1873 */
1874 bool m_invalid_stats{false};
1875
1876 /**
1877 For tmp tables. true <=> tmp table has been instantiated.
1878 Also indicates that table was successfully opened since
1879 we immediately delete tmp tables which we fail to open.
1880 */
1881 bool created{false};
1882
1883 public:
1884 /// For a materializable derived or SJ table: true if has been materialized
1885 bool materialized{false};
1886 struct /* field connections */
1887 {
1888 class JOIN_TAB *join_tab{nullptr};
1889 class QEP_TAB *qep_tab{nullptr};
1890 thr_lock_type lock_type{TL_UNLOCK}; /* How table is used */
1892 /*
1893 true <=> range optimizer found that there is no rows satisfying
1894 table conditions.
1895 */
1896 bool impossible_range{false};
1898
1899 /**
1900 @todo This member should not be declared in-line. That makes it
1901 impossible for any function that does memory allocation to take a const
1902 reference to a TABLE object.
1903 */
1905 /**
1906 Initialized in Item_func_group_concat::setup for appropriate
1907 temporary table if GROUP_CONCAT is used with ORDER BY | DISTINCT
1908 and BLOB field count > 0.
1909 */
1911
1912 /**
1913 Not owned by the TABLE; used only from filesort_free_buffers().
1914 See comments on SortingIterator::CleanupAfterQuery().
1915 */
1918
1919 /**
1920 The result of applying a unique operation (by row ID) to the table, if done.
1921 In particular, this is done in some forms of index merge.
1922 */
1924 partition_info *part_info{nullptr}; /* Partition related information */
1925 /* If true, all partitions have been pruned away */
1928
1929 private:
1930 /// Cost model object for operations on this table
1932#ifndef NDEBUG
1933 /**
1934 Internal tmp table sequential number. Increased in the order of
1935 creation. Used for debugging purposes when many tmp tables are used
1936 during execution (e.g several windows with window functions)
1937 */
1939#endif
1940 public:
1941 void reset();
1942 void init(THD *thd, Table_ref *tl);
1943 bool init_tmp_table(THD *thd, TABLE_SHARE *share, MEM_ROOT *m_root,
1944 CHARSET_INFO *charset, const char *alias, Field **fld,
1945 uint *blob_fld, bool is_virtual);
1946 bool fill_item_list(mem_root_deque<Item *> *item_list) const;
1947 void clear_column_bitmaps(void);
1948 void prepare_for_position(void);
1949
1952 uint key_parts = 0) const;
1954 void mark_auto_increment_column(void);
1955 void mark_columns_needed_for_update(THD *thd, bool mark_binlog_columns);
1959 void mark_generated_columns(bool is_update);
1960 void mark_gcol_in_maps(const Field *field);
1961 void mark_check_constraint_columns(bool is_update);
1962 void column_bitmaps_set(MY_BITMAP *read_set_arg, MY_BITMAP *write_set_arg);
1963 inline void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg,
1964 MY_BITMAP *write_set_arg) {
1965 read_set = read_set_arg;
1966 write_set = write_set_arg;
1967 }
1968 inline void use_all_columns() {
1970 }
1974 }
1975 void invalidate_dict();
1976 void invalidate_stats();
1977 /**
1978 @note Can be called by thread owning table without additional locking, and
1979 by any other thread which has acquired owner's THD::LOCK_thd_data lock.
1980 */
1981 inline bool has_invalid_dict() const {
1982 assert(assert_invalid_dict_is_locked(this));
1983 return !db_stat || m_invalid_dict;
1984 }
1985 /// @note Can be called by thread owning Table_cache::m_lock
1986 inline bool has_invalid_stats() {
1987 assert(assert_invalid_stats_is_locked(this));
1988 return m_invalid_stats;
1989 }
1990 /// @returns first non-hidden column
1992 /// @returns count of visible fields
1994 bool alloc_tmp_keys(uint new_key_count, uint new_key_part_count,
1995 bool modify_share);
1996 bool add_tmp_key(Field_map *key_parts, bool invisible, bool modify_share);
1997 void move_tmp_key(int old_idx, bool modify_share);
1998 void drop_unused_tmp_keys(bool modify_share);
1999
2000 void set_keyread(bool flag);
2001
2002 /**
2003 Check whether the given index has a virtual generated columns.
2004
2005 @param index_no the given index to check
2006
2007 @returns true if if index is defined over at least one virtual generated
2008 column
2009 */
2010 inline bool index_contains_some_virtual_gcol(uint index_no) const {
2011 assert(index_no < s->keys);
2012 return key_info[index_no].flags & HA_VIRTUAL_GEN_KEY;
2013 }
2014 void update_const_key_parts(Item *conds);
2015
2016 bool check_read_removal(uint index);
2017
2018 ptrdiff_t default_values_offset() const {
2019 return (ptrdiff_t)(s->default_values - record[0]);
2020 }
2021
2022 /// @returns true if a storage engine handler object is assigned to table
2023 bool has_storage_handler() const { return file != nullptr; }
2024
2025 /// Set storage handler for temporary table
2027 // Ensure consistent call order
2028 assert((file == nullptr && file_arg != nullptr) ||
2029 (file != nullptr && file_arg == nullptr));
2030 assert(!is_created());
2031 assert(file_arg->inited == handler::NONE);
2032 file = file_arg;
2033 }
2034 /// Return true if table is instantiated, and false otherwise.
2035 bool is_created() const { return created; }
2036
2037 /**
2038 Set the table as "created", and enable flags in storage engine
2039 that could not be enabled without an instantiated table.
2040 */
2041 void set_created();
2042 /**
2043 Set the contents of table to be "deleted", ie "not created", after having
2044 deleted the contents.
2045 */
2046 void set_deleted() { created = materialized = false; }
2047 /// Set table as nullable, ie it is inner wrt some outer join
2048 void set_nullable() { nullable = true; }
2049
2050 /// Return whether table is nullable
2051 bool is_nullable() const { return nullable; }
2052
2053 /// @return true if table contains one or more generated columns
2054 bool has_gcol() const { return vfield; }
2055
2056 /**
2057 Life cycle of the row buffer is as follows:
2058 - The initial state is "not started".
2059 - When reading a row through the storage engine handler, the status is set
2060 as "has row" or "no row", depending on whether a row was found or not.
2061 The "not started" state is cleared, as well as the "null row" state,
2062 the updated state and the deleted state.
2063 - When making a row available in record[0], make sure to update row status
2064 similarly to how the storage engine handler does it.
2065 - If a NULL-extended row is needed in join execution, the "null row" state
2066 is set. Note that this can be combined with "has row" if a row was read
2067 but condition on it was evaluated to false (happens for single-row
2068 lookup), or "no row" if no more rows could be read.
2069 Note also that for the "null row" state, the NULL bits inside the
2070 row are set to one, so the row inside the row buffer is no longer usable,
2071 unless the NULL bits are saved in a separate buffer.
2072 - The "is updated" and "is deleted" states are set when row is updated or
2073 deleted, respectively.
2074 */
2075 /// Set status for row buffer as "not started"
2078 null_row = false;
2079 }
2080
2081 /// @return true if a row operation has been done
2082 bool is_started() const { return !(m_status & STATUS_NOT_STARTED); }
2083
2084 /// Set status for row buffer: contains row
2086 m_status = 0;
2087 null_row = false;
2088 }
2089
2090 /**
2091 Set status for row buffer: contains no row. This is set when
2092 - A lookup operation finds no row
2093 - A scan operation scans past the last row of the range.
2094 - An error in generating key values before calling storage engine.
2095 */
2096 void set_no_row() {
2098 null_row = false;
2099 }
2100
2101 /**
2102 Set "row found" status from handler result
2103
2104 @param status 0 if row was found, <> 0 if row was not found
2105 */
2108 null_row = false;
2109 }
2110
2111 /**
2112 Set current row as "null row", for use in null-complemented outer join.
2113 The row buffer may or may not contain a valid row.
2114 set_null_row() and reset_null_row() are used by the join executor to
2115 signal the presence or absence of a NULL-extended row for an outer joined
2116 table. Null rows may also be used to specify rows that are all NULL in
2117 grouing operations.
2118 @note this is a destructive operation since the NULL value bit vector
2119 is overwritten. Caching operations must be aware of this.
2120 */
2122 null_row = true;
2124 if (s->null_bytes > 0) memset(null_flags, 255, s->null_bytes);
2125 }
2126
2127 /// Clear "null row" status for the current row
2129 null_row = false;
2130 m_status &= ~STATUS_NULL_ROW;
2131 }
2132
2133 /// Set "updated" property for the current row
2135 assert(is_started() && has_row());
2137 }
2138
2139 /// Set "deleted" property for the current row
2141 assert(is_started() && has_row());
2143 }
2144
2145 /// @return true if there is a row in row buffer
2146 bool has_row() const { return !(m_status & STATUS_NOT_FOUND); }
2147
2148 /// @return true if current row is null-extended
2149 bool has_null_row() const { return null_row; }
2150
2151 /// @return true if current row has been updated (multi-table update)
2152 bool has_updated_row() const { return m_status & STATUS_UPDATED; }
2153
2154 /// @return true if current row has been deleted (multi-table delete)
2155 bool has_deleted_row() const { return m_status & STATUS_DELETED; }
2156
2157 /// Save the NULL flags of the current row into the designated buffer.
2158 /// This should be done before null-complementing a table accessed
2159 /// with EQRefIterator or a const table, as they need to be able to
2160 /// restore the original contents of the record buffer before
2161 /// reading the next row. This is necessary because of their special
2162 /// code for avoiding table access if the same row should be
2163 /// accessed by the next read.
2165 if (s->null_bytes > 0) memcpy(null_flags_saved, null_flags, s->null_bytes);
2166 }
2167
2168 /// Restore the NULL flags of the current row from the designated buffer
2170 if (s->null_bytes > 0) memcpy(null_flags, null_flags_saved, s->null_bytes);
2171 }
2172
2173 /// Empties internal temporary table (deletes rows, closes scan)
2174 bool empty_result_table();
2175
2176 /**
2177 Initialize the optimizer cost model.
2178
2179 This function should be called each time a new query is started.
2180
2181 @param cost_model_server the main cost model object for the query
2182 */
2183 void init_cost_model(const Cost_model_server *cost_model_server) {
2184 m_cost_model.init(cost_model_server, this);
2185 }
2186
2187 /**
2188 Return the cost model object for this table.
2189 */
2190 const Cost_model_table *cost_model() const { return &m_cost_model; }
2191
2192 /**
2193 Bind all the table's value generator columns in all the forms:
2194 stored/virtual GC, default expressions and checked constraints.
2195
2196 @details When a table is opened from the dictionary, the Value Generator
2197 expressions are bound during opening (see fix_value_generator_fields()).
2198 After query execution, Item::cleanup() is called on them
2199 (see cleanup_value_generator_items()). When the table is opened from the
2200 table cache, the Value Generetor(s) need to be bound again and this
2201 function does that.
2202 */
2204
2205 /**
2206 Clean any state in items associated with generated columns to be ready for
2207 the next statement.
2208 */
2210
2211#ifndef NDEBUG
2212 void set_tmp_table_seq_id(uint arg) { tmp_table_seq_id = arg; }
2213#endif
2214 /**
2215 Update covering keys depending on max read key length.
2216
2217 Update available covering keys for the table, based on a constrained field
2218 and the identified covering prefix keys: If the matched part of field is
2219 longer than the index prefix,
2220 the prefix index cannot be used as a covering index.
2221
2222 @param[in] field Pointer to field object
2223 @param[in] key_read_length Max read key length
2224 @param[in] covering_prefix_keys Covering prefix keys
2225 */
2226 void update_covering_prefix_keys(Field *field, uint16 key_read_length,
2227 Key_map *covering_prefix_keys);
2228
2229 /**
2230 Returns the primary engine handler for the table.
2231 If none exist, nullptr is returned.
2232 */
2234
2235 private:
2236 /**
2237 Bitmap that tells which columns are eligible for partial update in an
2238 update statement.
2239
2240 The bitmap is lazily allocated in the TABLE's mem_root when
2241 #mark_column_for_partial_update() is called.
2242 */
2244
2245 /**
2246 Object which contains execution time state used for partial update
2247 of JSON columns.
2248
2249 It is allocated in the execution mem_root by #setup_partial_update() if
2250 there are columns that have been marked as eligible for partial update.
2251 */
2253
2254 /**
2255 This flag decides whether or not we should log the drop temporary table
2256 command.
2257 */
2259
2260 public:
2261 /**
2262 Does this table have any columns that can be updated using partial update
2263 in the current row?
2264
2265 @return whether any columns in the current row can be updated using partial
2266 update
2267 */
2268 bool has_binary_diff_columns() const;
2269
2270 /**
2271 Get the list of binary diffs that have been collected for a given column in
2272 the current row, or `nullptr` if partial update cannot be used for that
2273 column.
2274
2275 @param field the column to get binary diffs for
2276 @return the list of binary diffs for the column, or `nullptr` if the column
2277 cannot be updated using partial update
2278 */
2279 const Binary_diff_vector *get_binary_diffs(const Field *field) const;
2280
2281 /**
2282 Mark a given column as one that can potentially be updated using
2283 partial update during execution of an update statement.
2284
2285 Whether it is actually updated using partial update, is not
2286 determined until execution time, since that depends both on the
2287 data that is in the column and the new data that is written to the
2288 column.
2289
2290 This function should be called during preparation of an update
2291 statement.
2292
2293 @param field a column which is eligible for partial update
2294 @retval false on success
2295 @retval true on out-of-memory
2296 */
2298
2299 /**
2300 Has this column been marked for partial update?
2301
2302 Note that this only tells if the column satisfies the syntactical
2303 requirements for being partially updated. Use #is_binary_diff_enabled() or
2304 #is_logical_diff_enabled() instead to see if partial update should be used
2305 on the column.
2306
2307 @param field the column to check
2308 @return whether the column has been marked for partial update
2309 */
2310 bool is_marked_for_partial_update(const Field *field) const;
2311
2312 /**
2313 Does this table have any columns that were marked with
2314 #mark_column_for_partial_update()?
2315
2316 Note that this only tells if any of the columns satisfy the syntactical
2317 requirements for being partially updated. Use
2318 #has_binary_diff_columns(), #is_binary_diff_enabled() or
2319 #is_logical_diff_enabled() instead to see if partial update should be used
2320 on a column.
2321 */
2323
2324 /**
2325 Enable partial update of JSON columns in this table. It is only
2326 enabled for the columns that have previously been marked for
2327 partial update using #mark_column_for_partial_update().
2328
2329 @param logical_diffs should logical JSON diffs be collected in addition
2330 to the physical binary diffs?
2331
2332 This function should be called once per statement execution, when
2333 the update statement is optimized.
2334
2335 @retval false on success
2336 @retval true on out-of-memory
2337 */
2338 bool setup_partial_update(bool logical_diffs);
2339
2340 /**
2341 @see setup_partial_update(bool)
2342
2343 This is a wrapper that auto-computes the value of the parameter
2344 logical_diffs.
2345
2346 @retval false on success
2347 @retval true on out-of-memory
2348 */
2349 bool setup_partial_update();
2350
2351 /**
2352 Add a binary diff for a column that is updated using partial update.
2353
2354 @param field the column that is being updated
2355 @param offset the offset of the changed portion
2356 @param length the length of the changed portion
2357
2358 @retval false on success
2359 @retval true on out-of-memory
2360 */
2361 bool add_binary_diff(const Field *field, size_t offset, size_t length);
2362
2363 /**
2364 Clear the diffs that have been collected for partial update of
2365 JSON columns, and re-enable partial update for any columns where
2366 partial update was temporarily disabled for the current row.
2367 Should be called between each row that is updated.
2368 */
2370
2371 /**
2372 Clean up state used for partial update of JSON columns.
2373
2374 This function should be called at the end of each statement
2375 execution.
2376 */
2378
2379 /**
2380 Temporarily disable collection of binary diffs for a column in the current
2381 row.
2382
2383 This function is called during execution to disable partial update of a
2384 column that was previously marked as eligible for partial update with
2385 #mark_column_for_partial_update() during preparation.
2386
2387 Partial update of this column will be re-enabled when we go to the next
2388 row.
2389
2390 @param field the column to stop collecting binary diffs for
2391 */
2393
2394 /**
2395 Temporarily disable collection of Json_diff objects describing the
2396 logical changes of a JSON column in the current row.
2397
2398 Collection of logical JSON diffs is re-enabled when we go to the next row.
2399
2400 @param field the column to stop collecting logical JSON diffs for
2401 */
2403
2404 /**
2405 Get a buffer that can be used to hold the partially updated column value
2406 while performing partial update.
2407 */
2409
2410 /**
2411 Add a logical JSON diff describing a logical change to a JSON column in
2412 partial update.
2413
2414 @param field the column that is updated
2415 @param path the JSON path that is changed
2416 @param operation the operation to perform
2417 @param new_value the new value in the path
2418
2419 @throws std::bad_alloc if memory cannot be allocated
2420 */
2422 enum_json_diff_operation operation,
2423 const Json_wrapper *new_value);
2424
2425 /**
2426 Get the list of JSON diffs that have been collected for a given column in
2427 the current row, or `nullptr` if partial update cannot be used for that
2428 column.
2429
2430 @param field the column to get JSON diffs for
2431 @return the list of JSON diffs for the column, or `nullptr` if the column
2432 cannot be updated using partial update
2433 */
2435
2436 /**
2437 Is partial update using binary diffs enabled on this JSON column?
2438
2439 @param field the column to check
2440 @return whether the column can be updated with binary diffs
2441 */
2442 bool is_binary_diff_enabled(const Field *field) const;
2443
2444 /**
2445 Is partial update using logical diffs enabled on this JSON column?
2446
2447 @param field the column to check
2448 @return whether the column can be updated with JSON diffs
2449 */
2450 bool is_logical_diff_enabled(const Field *field) const;
2451
2452 /**
2453 Virtual fields of type BLOB have a flag m_keep_old_value. This flag is set
2454 to false for all such fields in this table.
2455 */
2457
2458 /**
2459 Set the variable should_binlog_drop_if_temp_flag, so that
2460 the logging of temporary tables can be decided.
2461
2462 @param should_binlog the value to set flag should_binlog_drop_if_temp_flag
2463 */
2464 void set_binlog_drop_if_temp(bool should_binlog);
2465
2466 /**
2467 @return whether should_binlog_drop_if_temp_flag flag is
2468 set or not
2469 */
2470 bool should_binlog_drop_if_temp(void) const;
2471
2472 /**
2473 Find the histogram for the given field index.
2474
2475 @note If this is called on a TABLE object that belongs to a secondary
2476 engine, it will take a round-trip through the handler in order to obtain the
2477 histogram from the TABLE object associated with the primary engine. This is
2478 done to avoid storing histograms on both the primary and secondary
2479 TABLE_SHARE.
2480
2481 @param field_index The index of the field we want to find a histogram for.
2482
2483 @retval nullptr if no histogram is found.
2484 @retval Pointer to a histogram if one is found.
2485 */
2486 const histograms::Histogram *find_histogram(uint field_index) const;
2487};
2488
2489static inline void empty_record(TABLE *table) {
2490 restore_record(table, s->default_values);
2491 if (table->s->null_bytes > 0)
2492 memset(table->null_flags, 255, table->s->null_bytes);
2493}
2494
2495#define MY_I_S_MAYBE_NULL 1
2496#define MY_I_S_UNSIGNED 2
2497
2499 /**
2500 This is used as column name.
2501 */
2502 const char *field_name;
2503 /**
2504 For string-type columns, this is the maximum number of
2505 characters. Otherwise, it is the 'display-length' for the column.
2506 For the data type MYSQL_TYPE_DATETIME this field specifies the
2507 number of digits in the fractional part of time value.
2508 */
2510 /**
2511 This denotes data type for the column. For the most part, there seems to
2512 be one entry in the enum for each SQL data type, although there seem to
2513 be a number of additional entries in the enum.
2514 */
2517 /**
2518 This is used to set column attributes. By default, columns are @c NOT
2519 @c NULL and @c SIGNED, and you can deviate from the default
2520 by setting the appropriate flags. You can use either one of the flags
2521 @c MY_I_S_MAYBE_NULL and @c MY_I_S_UNSIGNED or
2522 combine them using the bitwise or operator @c |. Both flags are
2523 defined in table.h.
2524 */
2525 uint field_flags; // Field attributes (maybe_null, signed, unsigned etc.)
2526 const char *old_name;
2527 uint open_method; // Not used
2528};
2529
2531 const char *table_name;
2533 /* Fill table with data */
2534 int (*fill_table)(THD *thd, Table_ref *tables, Item *cond);
2535 /* Handle fields for old SHOW */
2536 int (*old_format)(THD *thd, ST_SCHEMA_TABLE *schema_table);
2537 int (*process_table)(THD *thd, Table_ref *tables, TABLE *table, bool res,
2540};
2541
2542/**
2543 Strategy for how to process a view or derived table (merge or materialization)
2544*/
2550
2551#define VIEW_SUID_INVOKER 0
2552#define VIEW_SUID_DEFINER 1
2553#define VIEW_SUID_DEFAULT 2
2554
2555/* view WITH CHECK OPTION parameter options */
2556#define VIEW_CHECK_NONE 0
2557#define VIEW_CHECK_LOCAL 1
2558#define VIEW_CHECK_CASCADED 2
2559
2560/* result of view WITH CHECK OPTION parameter check */
2561#define VIEW_CHECK_OK 0
2562#define VIEW_CHECK_ERROR 1
2563#define VIEW_CHECK_SKIP 2
2564
2565/** The threshold size a blob field buffer before it is freed */
2566#define MAX_TDC_BLOB_SIZE 65536
2567
2568/**
2569 Struct that describes an expression selected from a derived table or view.
2570*/
2572 /**
2573 Points to an item that represents the expression.
2574 If the item is determined to be unused, the pointer is set to NULL.
2575 */
2577 /// Name of selected expression
2578 const char *name;
2579};
2580
2581/*
2582 Column reference of a NATURAL/USING join. Since column references in
2583 joins can be both from views and stored tables, may point to either a
2584 Field (for tables), or a Field_translator (for views).
2585*/
2586
2588 public:
2589 Field_translator *view_field; /* Column reference of merge view. */
2590 Item_field *table_field; /* Column reference of table or temp view. */
2591 Table_ref *table_ref; /* Original base table/view reference. */
2592 /*
2593 True if a common join column of two NATURAL/USING join operands. Notice
2594 that when we have a hierarchy of nested NATURAL/USING joins, a column can
2595 be common at some level of nesting but it may not be common at higher
2596 levels of nesting. Thus this flag may change depending on at which level
2597 we are looking at some column.
2598 */
2600
2601 public:
2603 Natural_join_column(Item_field *field_param, Table_ref *tab);
2604 const char *name();
2605 Item *create_item(THD *thd);
2606 Field *field();
2607 const char *table_name();
2608 const char *db_name();
2609 GRANT_INFO *grant();
2610};
2611
2612/**
2613 This is generic enum. It may be reused in the ACL statements
2614 for clauses that can map to the values defined in this enum.
2615*/
2617 UNCHANGED, /* The clause is not specified */
2618 DEFAULT, /* Default value of clause is specified */
2619 YES, /* Value that maps to True is specified */
2620 NO /* Value that maps to False is specified */
2621};
2622
2623struct LEX_MFA {
2630 /*
2631 The following flags are indicators for the SQL syntax used while
2632 parsing CREATE/ALTER user. While other members are self-explanatory,
2633 'uses_authentication_string_clause' signifies if the password is in
2634 hash form (if the var was set to true) or not.
2635 */
2640 /* flag set during CREATE USER .. INITIAL AUTHENTICATION BY */
2642 /* flag set during ALTER USER .. ADD nth FACTOR */
2644 /* flag set during ALTER USER .. MODIFY nth FACTOR */
2646 /* flag set during ALTER USER .. DROP nth FACTOR */
2648 /*
2649 flag used during authentication and to decide if server should
2650 be in sandbox mode or not
2651 */
2653 /* flag set during ALTER USER .. nth FACTOR UNREGISTER */
2655 /* flag set during ALTER USER .. INITIATE REGISTRATION */
2657 /* flag set during ALTER USER .. FINISH REGISTRATION */
2659
2661 void reset() {
2663 auth = NULL_CSTR;
2667 nth_factor = 1;
2671 has_password_generator = false;
2672 passwordless = false;
2673 add_factor = false;
2674 drop_factor = false;
2675 modify_factor = false;
2676 requires_registration = false;
2677 unregister = false;
2678 init_registration = false;
2679 finish_registration = false;
2680 }
2681 void copy(LEX_MFA *m, MEM_ROOT *alloc);
2682};
2683
2684/*
2685 This structure holds the specifications relating to
2686 ALTER user ... PASSWORD EXPIRE ...
2687*/
2705 /* Holds the specification of 'PASSWORD REQUIRE CURRENT' clause. */
2707 void cleanup() {
2713 account_locked = false;
2725 }
2726};
2727
2728/*
2729 This structure holds the specifications related to
2730 mysql user and the associated auth details.
2731*/
2732struct LEX_USER {
2740 /* restrict MFA methods to atmost 3 authentication plugins */
2744
2745 void init() {
2746 user = NULL_CSTR;
2747 host = NULL_CSTR;
2749 uses_replace_clause = false;
2751 discard_old_password = false;
2768 mfa_list.clear();
2769 with_initial_auth = false;
2770 }
2771
2773
2774 bool add_mfa_identifications(LEX_MFA *factor2, LEX_MFA *factor3 = nullptr);
2775
2776 /*
2777 Allocates the memory in the THD mem pool and initialize the members of
2778 this struct. It is preferable to use this method to create a LEX_USER
2779 rather allocating the memory in the THD and initializing the members
2780 explicitly.
2781 */
2782 static LEX_USER *alloc(THD *thd);
2783 static LEX_USER *alloc(THD *thd, LEX_STRING *user, LEX_STRING *host);
2784 /*
2785 Initialize the members of this struct. It is preferable to use this method
2786 to initialize a LEX_USER rather initializing the members explicitly.
2787 */
2788 static LEX_USER *init(LEX_USER *to_init, THD *thd, LEX_STRING *user,
2789 LEX_STRING *host);
2790};
2791
2792/**
2793 Derive type of metadata lock to be requested for table used by a DML
2794 statement from the type of THR_LOCK lock requested for this table.
2795*/
2796
2797inline enum enum_mdl_type mdl_type_for_dml(enum thr_lock_type lock_type) {
2798 return lock_type >= TL_WRITE_ALLOW_WRITE
2802}
2803
2804/**
2805 Type of table which can be open for an element of table list.
2806*/
2807
2813
2814/**
2815 This structure is used to keep info about possible key for the result table
2816 of a derived table/view.
2817 The 'referenced_by' is the table map of tables to which this possible
2818 key corresponds.
2819 The 'used_field' is a map of fields of which this key consists of.
2820 See also the comment for the Table_ref::update_derived_keys function.
2821*/
2822
2824 public:
2828};
2829
2830class Table_function;
2831/*
2832 Table reference in the FROM clause.
2833
2834 These table references can be of several types that correspond to
2835 different SQL elements. Below we list all types of TABLE_LISTs with
2836 the necessary conditions to determine when a Table_ref instance
2837 belongs to a certain type.
2838
2839 1) table (Table_ref::view == NULL)
2840 - base table
2841 (Table_ref::derived == NULL)
2842 - subquery - Table_ref::table is a temp table
2843 (Table_ref::derived != NULL)
2844 - information schema table
2845 (Table_ref::schema_table != NULL)
2846 NOTICE: for schema tables Table_ref::field_translation may be != NULL
2847 2) view (Table_ref::view != NULL)
2848 - merge (Table_ref::effective_algorithm == VIEW_ALGORITHM_MERGE)
2849 also (Table_ref::field_translation != NULL)
2850 - temptable(Table_ref::effective_algorithm == VIEW_ALGORITHM_TEMPTABLE)
2851 also (Table_ref::field_translation == NULL)
2852 3) nested table reference (Table_ref::nested_join != NULL)
2853 - table sequence - e.g. (t1, t2, t3)
2854 TODO: how to distinguish from a JOIN?
2855 - general JOIN
2856 TODO: how to distinguish from a table sequence?
2857 - NATURAL JOIN
2858 (Table_ref::natural_join != NULL)
2859 - JOIN ... USING
2860 (Table_ref::join_using_fields != NULL)
2861 - semi-join
2862 ;
2863*/
2864
2866 public:
2867 Table_ref() = default;
2868
2869 /**
2870 Only to be used by legacy code that temporarily needs a Table_ref,
2871 more specifically: Query_result_create::binlog_show_create_table().
2872 */
2873 explicit Table_ref(TABLE *table_arg) : table(table_arg) {}
2874
2875 /// Constructor that can be used when the strings are null terminated.
2876 Table_ref(const char *db_name, const char *table_name,
2877 enum thr_lock_type lock_type)
2878 : Table_ref(db_name, strlen(db_name), table_name, strlen(table_name),
2879 table_name, lock_type) {}
2880
2881 /**
2882 Creates a Table_ref object with pre-allocated strings for database,
2883 table and alias.
2884 */
2885 Table_ref(TABLE *table_arg, const char *db_name_arg, size_t db_length_arg,
2886 const char *table_name_arg, size_t table_name_length_arg,
2887 const char *alias_arg, enum thr_lock_type lock_type_arg)
2888 : db(db_name_arg),
2889 table_name(table_name_arg),
2890 alias(alias_arg),
2891 m_map(1),
2892 table(table_arg),
2893 m_lock_descriptor{lock_type_arg},
2894 db_length(db_length_arg),
2895 table_name_length(table_name_length_arg) {
2898 }
2899
2900 /// Constructor that can be used when the strings are null terminated.
2901 Table_ref(const char *db_name, const char *table_name, const char *alias,
2902 enum thr_lock_type lock_type)
2903 : Table_ref(db_name, strlen(db_name), table_name, strlen(table_name),
2904 alias, lock_type) {}
2905
2906 /**
2907 This constructor can be used when a Table_ref is needed for an
2908 existing temporary table. These typically have very long table names, since
2909 it is a fully qualified path. For this reason, the table is set to the
2910 alias. The database name is left blank. The lock descriptor is set to
2911 TL_READ.
2912 */
2913 Table_ref(TABLE *table_arg, const char *alias_arg)
2914 : db(""),
2915 table_name(alias_arg),
2916 alias(alias_arg),
2917 m_map(1),
2918 table(table_arg),
2920 db_length(0),
2921 table_name_length(strlen(alias_arg)) {
2924 }
2925
2926 /**
2927 Sets an explicit enum_mdl_type value, without initializing
2928 m_lock_descriptor.
2929 */
2930 Table_ref(TABLE *table_arg, const char *alias_arg, enum_mdl_type mdl_type)
2931 : db(table_arg->s->db.str),
2932 table_name(table_arg->s->table_name.str),
2933 alias(alias_arg),
2934 m_map(1),
2935 table(table_arg),
2936 db_length(table_arg->s->db.length),
2937 table_name_length(table_arg->s->table_name.length) {
2940 }
2941
2942 Table_ref(const char *db_name, const char *table_name_arg,
2943 enum thr_lock_type lock_type_arg,
2944 enum enum_mdl_type mdl_request_type)
2945 : db(db_name),
2946 table_name(table_name_arg),
2947 alias(table_name_arg),
2948 m_map(1),
2949 m_lock_descriptor{lock_type_arg},
2950 db_length(strlen(db_name)),
2951 table_name_length(strlen(table_name_arg)) {
2954 mdl_request.set_type(mdl_request_type);
2955 }
2956
2957 Table_ref(const char *db_name, size_t db_length_arg,
2958 const char *table_name_arg, size_t table_name_length_arg,
2959 enum thr_lock_type lock_type_arg,
2960 enum enum_mdl_type mdl_request_type)
2961 : db(db_name),
2962 table_name(table_name_arg),
2963 alias(table_name_arg),
2964 m_map(1),
2965 m_lock_descriptor{lock_type_arg},
2966 db_length(db_length_arg),
2967 table_name_length(table_name_length_arg) {
2970 mdl_request.set_type(mdl_request_type);
2971 }
2972
2973 Table_ref(const char *db_name, size_t db_length_arg,
2974 const char *table_name_arg, size_t table_name_length_arg,
2975 enum thr_lock_type lock_type_arg)
2976 : db(db_name),
2977 table_name(table_name_arg),
2978 alias(table_name_arg),
2979 m_map(1),
2980 m_lock_descriptor{lock_type_arg},
2981 db_length(db_length_arg),
2982 table_name_length(table_name_length_arg) {}
2983
2984 /**
2985 Sets an explicit enum_mdl_type value, without initializing
2986 m_lock_descriptor.
2987 */
2988 Table_ref(const char *db_name, size_t db_length_arg,
2989 const char *table_name_arg, size_t table_name_length_arg,
2990 const char *alias_arg, enum enum_mdl_type mdl_request_type)
2991 : db(db_name),
2992 table_name(table_name_arg),
2993 alias(alias_arg),
2994 m_map(1),
2995 db_length(db_length_arg),
2996 table_name_length(table_name_length_arg) {
2999 mdl_request.set_type(mdl_request_type);
3000 }
3001
3002 Table_ref(const char *db_name, size_t db_length_arg,
3003 const char *table_name_arg, size_t table_name_length_arg,
3004 const char *alias_arg, enum thr_lock_type lock_type_arg,
3005 enum enum_mdl_type mdl_request_type)
3006 : db(db_name),
3007 table_name(table_name_arg),
3008 alias(alias_arg),
3009 m_map(1),
3010 m_lock_descriptor{lock_type_arg},
3011 db_length(db_length_arg),
3012 table_name_length(table_name_length_arg) {
3015 mdl_request.set_type(mdl_request_type);
3016 }
3017
3018 Table_ref(const char *db_name_arg, size_t db_length_arg,
3019 const char *table_name_arg, size_t table_name_length_arg,
3020 const char *alias_arg, enum thr_lock_type lock_type_arg)
3021 : db(db_name_arg),
3022 table_name(table_name_arg),
3023 alias(alias_arg),
3024 m_map(1),
3025 m_lock_descriptor{lock_type_arg},
3026 db_length(db_length_arg),
3027 table_name_length(table_name_length_arg) {
3030 }
3031
3032 /// Create a Table_ref object representing a nested join
3033 static Table_ref *new_nested_join(MEM_ROOT *allocator, const char *alias,
3035 mem_root_deque<Table_ref *> *belongs_to,
3036 Query_block *select);
3038 Item *join_cond() const { return m_join_cond; }
3039 void set_join_cond(Item *val) {
3040 // If optimization has started, it's too late to change m_join_cond.
3041 assert(m_join_cond_optim == nullptr || m_join_cond_optim == (Item *)1);
3042 m_join_cond = val;
3043 }
3046 /*
3047 Either we are setting to "empty", or there must pre-exist a
3048 permanent condition.
3049 */
3050 assert(cond == nullptr || cond == (Item *)1 || m_join_cond != nullptr);
3051 m_join_cond_optim = cond;
3052 }
3054
3055 /// @returns true if semi-join nest
3056 bool is_sj_nest() const { return m_is_sj_or_aj_nest && !m_join_cond; }
3057 /// @returns true if anti-join nest
3058 bool is_aj_nest() const { return m_is_sj_or_aj_nest && m_join_cond; }
3059 /// @returns true if anti/semi-join nest
3060 bool is_sj_or_aj_nest() const { return m_is_sj_or_aj_nest; }
3061 /// Makes the next a semi/antijoin nest
3063 assert(!m_is_sj_or_aj_nest);
3064 m_is_sj_or_aj_nest = true;
3065 }
3066
3067 /// Merge tables from a query block into a nested join structure
3069
3070 /// Reset table
3071 void reset();
3072
3073 /// Evaluate the check option of a view
3074 int view_check_option(THD *thd) const;
3075
3076 /// Produce a textual identification of this object
3077 void print(const THD *thd, String *str, enum_query_type query_type) const;
3078
3079 /// Check which single table inside a view that matches a table map
3080 bool check_single_table(Table_ref **table_ref, table_map map);
3081
3082 /// Allocate a buffer for inserted column values
3084
3086 /**
3087 Retrieve the last (right-most) leaf in a nested join tree with
3088 respect to name resolution.
3089
3090
3091 Given that 'this' is a nested table reference, recursively walk
3092 down the right-most children of 'this' until we reach a leaf
3093 table reference with respect to name resolution.
3094
3095 The right-most child of a nested table reference is the first
3096 element in the list of children because the children are inserted
3097 in reverse order.
3098
3099 @return
3100 - If 'this' is a nested table reference - the right-most child
3101 of the tree rooted in 'this',
3102 - else - 'this'
3103 */
3105 bool is_leaf_for_name_resolution() const;
3106
3107 /// Return the outermost view this table belongs to, or itself
3108 inline const Table_ref *top_table() const {
3109 return belong_to_view ? belong_to_view : this;
3110 }
3111
3113 return const_cast<Table_ref *>(
3114 const_cast<const Table_ref *>(this)->top_table());
3115 }
3116
3117 /// Prepare check option for a view
3118 bool prepare_check_option(THD *thd, bool is_cascaded = false);
3119
3120 /// Merge WHERE condition of view or derived table into outer query
3121 bool merge_where(THD *thd);
3122
3123 /// Prepare replace filter for a view (used for REPLACE command)
3124 bool prepare_replace_filter(THD *thd);
3125
3126 /// Return true if this represents a named view
3127 bool is_view() const { return view != nullptr; }
3128
3129 /// Return true if this represents a derived table (an unnamed view)
3130 bool is_derived() const { return derived != nullptr && view == nullptr; }
3131
3132 /// Return true if this represents a named view or a derived table
3133 bool is_view_or_derived() const { return derived != nullptr; }
3134
3135 /// Return true if this represents a table function
3136 bool is_table_function() const { return table_function != nullptr; }
3137 /**
3138 @returns true if this is a recursive reference inside the definition of a
3139 recursive CTE.
3140 @note that it starts its existence as a dummy derived table, until the
3141 end of resolution when it's not a derived table anymore, just a reference
3142 to the materialized temporary table. Whereas a non-recursive
3143 reference to the recursive CTE is a derived table.
3144 */
3146
3147 /// @returns true if this is a base table (permanent or temporary)
3148 bool is_base_table() const {
3149 return !(is_view_or_derived() || is_table_function() ||
3151 }
3152 /**
3153 @see is_recursive_reference().
3154 @returns true if error
3155 */
3157
3158 /**
3159 @returns true for a table that represents an optimizer internal table,
3160 is a derived table, a recursive reference, a table function.
3161 Internal tables are only visible inside a query expression, and is hence
3162 not visible in any schema, or need any kind of privilege checking.
3163 */
3164 bool is_internal() const {
3166 }
3167
3168 /**
3169 @returns true for a table that is a placeholder, ie a derived table,
3170 a view, a recursive reference, a table function or a schema table.
3171 A table is also considered to be a placeholder if it does not have a
3172 TABLE object for some other reason.
3173 */
3174 bool is_placeholder() const {
3176 is_table_function() || schema_table || table == nullptr;
3177 }
3178
3179 /// Return true if view or derived table and can be merged
3180 bool is_mergeable() const;
3181
3182 /**
3183 Checks if this is a table that contains zero rows or one row, and that can
3184 be materialized during optimization.
3185
3186 @returns true if materializable table contains one or zero rows, and
3187 materialization during optimization is permitted
3188
3189 Returning true, if the hypergraph optimizer is not active, implies that the
3190 table is materialized during optimization, so it need not be optimized
3191 during execution. The hypergraph optimizer does not care about const tables,
3192 so such tables are not executed during optimization time when it is active.
3193 */
3194 bool materializable_is_const(THD *thd) const;
3195
3196 /// @returns true if this is a derived table containing a stored function.
3197 bool has_stored_program() const;
3198
3199 /// Return true if this is a derived table or view that is merged
3201
3202 /// Set table to be merged
3203 void set_merged() {
3206 }
3207
3208 /// Return true if this is a materializable derived table/view
3211 }
3212
3213 /// Set table to be materialized
3215 // @todo We should do this only once, but currently we cannot:
3216 // assert(effective_algorithm == VIEW_ALGORITHM_UNDEFINED);
3219 }
3220
3221 /// Return true if table is updatable
3222 bool is_updatable() const { return m_updatable; }
3223
3224 /// Set table as updatable. (per default, a table is non-updatable)
3225 void set_updatable() { m_updatable = true; }
3226
3227 /// Return true if table is insertable-into
3228 bool is_insertable() const { return m_insertable; }
3229
3230 /// Set table as insertable-into. (per default, a table is not insertable)
3231 void set_insertable() { m_insertable = true; }
3232
3233 /// Return true if table is being updated
3234 bool is_updated() const { return m_updated; }
3235
3236 /// Set table and all referencing views as being updated
3238 for (Table_ref *tr = this; tr != nullptr; tr = tr->referencing_view)
3239 tr->m_updated = true;
3240 }
3241
3242 /// Return true if table is being inserted into
3243 bool is_inserted() const { return m_inserted; }
3244
3245 /// Set table and all referencing views as being inserted into
3247 for (Table_ref *tr = this; tr != nullptr; tr = tr->referencing_view)
3248 tr->m_inserted = true;
3249 }
3250
3251 /// Return true if table is being deleted from
3252 bool is_deleted() const { return m_deleted; }
3253
3254 /// Set table and all referencing views as being deleted from
3256 for (Table_ref *tr = this; tr != nullptr; tr = tr->referencing_view)
3257 tr->m_deleted = true;
3258 }
3259
3260 /// Set table as full-text search (default is not fulltext searched)
3262
3263 /// Returns true if a MATCH function references this table.
3265
3266 /// Is this table only available in an external storage engine?
3267 bool is_external() const;
3268
3269 /**
3270 Set table as readonly, ie it is neither updatable, insertable nor
3271 deletable during this statement.
3272 */
3274 m_updatable = false;
3275 m_insertable = false;
3276 }
3277
3278 /**
3279 Return true if this is a view or derived table that is defined over
3280 more than one base table, and false otherwise.
3281 */
3282 bool is_multiple_tables() const {
3283 if (is_view_or_derived()) {
3284 assert(is_merged()); // Cannot be a materialized view
3285 return leaf_tables_count() > 1;
3286 } else {
3287 assert(nested_join == nullptr); // Must be a base table
3288 return false;
3289 }
3290 }
3291
3292 /// Return no. of base tables a merged view or derived table is defined over.
3293 uint leaf_tables_count() const;
3294
3295 /// Return first leaf table of a base table or a view/derived table
3297 Table_ref *tr = this;
3298 while (tr->merge_underlying_list) tr = tr->merge_underlying_list;
3299 return tr;
3300 }
3301
3302 /// Return any leaf table that is not an inner table of an outer join
3303 /// @todo WL#6570 with prepare-once, replace with first_leaf_table()
3304 /// when WL#6059 is merged in (it really converts RIGHT JOIN to
3305 /// LEFT JOIN so the first leaf is part of a LEFT JOIN,
3306 /// guaranteed).
3308 Table_ref *tr = this;
3309 while (tr->merge_underlying_list) {
3310 tr = tr->merge_underlying_list;
3311 /*
3312 "while" is used, however, an "if" might be sufficient since there is
3313 no more than one inner table in a join nest (with outer_join true).
3314 */
3315 while (tr->outer_join) tr = tr->next_local;
3316 }
3317 return tr;
3318 }
3319 /**
3320 Set the LEX object of a view (will also define this as a view).
3321 @note: The value 1 is used to indicate a view but without a valid
3322 query object. Use only if the LEX object is not going to
3323 be used in later processing.
3324 */
3325 void set_view_query(LEX *lex) { view = lex; }
3326
3327 /// Return the valid LEX object for a view.
3328 LEX *view_query() const {
3329 assert(view != nullptr && view != (LEX *)1);
3330 return view;
3331 }
3332
3333 /**
3334 Set the query expression of a derived table or view.
3335 (Will also define this as a derived table, unless it is a named view.)
3336 */
3338 derived = query_expr;
3339 }
3340
3341 /// Return the query expression of a derived table or view.
3343 assert(derived);
3344 return derived;
3345 }
3346
3347 /// Resolve a derived table or view reference
3348 bool resolve_derived(THD *thd, bool apply_semijoin);
3349
3350 /// Optimize the query expression representing a derived table/view
3351 bool optimize_derived(THD *thd);
3352
3353 /// Create result table for a materialized derived table/view
3354 bool create_materialized_table(THD *thd);
3355
3356 /// Materialize derived table
3357 bool materialize_derived(THD *thd);
3358
3359 /// Check if we can push outer where condition to this derived table
3361
3362 /// Return the number of hidden fields added for the temporary table
3363 /// created for this derived table.
3365
3366 /// Prepare security context for a view
3367 bool prepare_security(THD *thd);
3368
3371
3372 /**
3373 Compiles the tagged hints list and fills up TABLE::keys_in_use_for_query,
3374 TABLE::keys_in_use_for_group_by, TABLE::keys_in_use_for_order_by,
3375 TABLE::force_index and TABLE::covering_keys.
3376 */
3377 bool process_index_hints(const THD *thd, TABLE *table);
3378
3379 /**
3380 Compare the version of metadata from the previous execution
3381 (if any) with values obtained from the current table
3382 definition cache element.
3383
3384 @sa check_and_update_table_version()
3385 */
3387 return (m_table_ref_type == s->get_table_ref_type() &&
3389 }
3390
3391 /**
3392 Record the value of metadata version of the corresponding
3393 table definition cache element in this parse tree node.
3394
3395 @sa check_and_update_table_version()
3396 */
3399 }
3400
3401 void set_table_ref_id(enum_table_ref_type table_ref_type_arg,
3402 ulonglong table_ref_version_arg) {
3403 m_table_ref_type = table_ref_type_arg;
3404 m_table_ref_version = table_ref_version_arg;
3405 }
3406
3407 /**
3408 If a derived table, returns query block id of first underlying query block.
3409 Zero if not derived.
3410 */
3411 uint query_block_id() const;
3412
3413 /**
3414 This is for showing in EXPLAIN.
3415 If a derived table, returns query block id of first underlying query block
3416 of first materialized Table_ref instance. Zero if not derived.
3417 */
3418 uint query_block_id_for_explain() const;
3419
3420 /**
3421 @brief Returns the name of the database that the referenced table belongs
3422 to.
3423 */
3424 const char *get_db_name() const { return db; }
3425
3426 /**
3427 @brief Returns the name of the table that this Table_ref represents.
3428
3429 @details The unqualified table name or view name for a table or view,
3430 respectively.
3431 */
3432 const char *get_table_name() const { return table_name; }
3434 ha_rows fallback_estimate = PLACEHOLDER_TABLE_ROW_ESTIMATE);
3435 bool update_derived_keys(THD *, Field *, Item **, uint, bool *);
3436 bool generate_keys();
3437
3438 /// Setup a derived table to use materialization
3441
3442 /// Setup a table function to use materialization
3443 bool setup_table_function(THD *thd);
3444
3445 bool create_field_translation(THD *thd);
3446
3447 /**
3448 @brief Returns the outer join nest that this Table_ref belongs to, if
3449 any.
3450
3451 @details There are two kinds of join nests, outer-join nests and semi-join
3452 nests. This function returns non-NULL in the following cases:
3453 @li 1. If this table/nest is embedded in a nest and this nest IS NOT a
3454 semi-join nest. (In other words, it is an outer-join nest.)
3455 @li 2. If this table/nest is embedded in a nest and this nest IS a
3456 semi-join nest, but this semi-join nest is embedded in another
3457 nest. (This other nest will be an outer-join nest, since all inner
3458 joined nested semi-join nests have been merged in
3459 @c simplify_joins() ).
3460 Note: This function assumes that @c simplify_joins() has been performed.
3461 Before that, join nests will be present for all types of join.
3462
3463 @return outer join nest, or NULL if none.
3464 */
3465
3467 if (!embedding) return nullptr;
3468 if (embedding->is_sj_nest()) return embedding->embedding;
3469 return embedding;
3470 }
3471 /**
3472 Return true if this table is an inner table of some outer join.
3473
3474 Examine all the embedding join nests of the table.
3475 @note This function works also before redundant join nests have been
3476 eliminated.
3477
3478 @return true if table is an inner table of some outer join, false otherwise.
3479 */
3480
3482 if (outer_join) return true;
3483 for (Table_ref *emb = embedding; emb; emb = emb->embedding) {
3484 if (emb->outer_join) return true;
3485 }
3486 return false;
3487 }
3488
3489 /**
3490 Return the base table entry of an updatable table.
3491 In DELETE and UPDATE, a view used as a target table must be mergeable,
3492 updatable and defined over a single table.
3493 */
3495 const Table_ref *tbl = this;
3496 assert(tbl->is_updatable() && !tbl->is_multiple_tables());
3497 while (tbl->is_view_or_derived()) {
3498 tbl = tbl->merge_underlying_list;
3499 assert(tbl->is_updatable() && !tbl->is_multiple_tables());
3500 }
3501 return tbl;
3502 }
3503
3505 return const_cast<Table_ref *>(
3506 static_cast<const Table_ref *>(this)->updatable_base_table());
3507 }
3508
3509 /**
3510 Mark that there is a NATURAL JOIN or JOIN ... USING between two tables.
3511
3512 This function marks that table b should be joined with a either via
3513 a NATURAL JOIN or via JOIN ... USING. Both join types are special
3514 cases of each other, so we treat them together. The function
3515 setup_conds() creates a list of equal condition between all fields
3516 of the same name for NATURAL JOIN or the fields in
3517 Table_ref::join_using_fields for JOIN ... USING.
3518 The list of equality conditions is stored
3519 either in b->join_cond(), or in JOIN::conds, depending on whether there
3520 was an outer join.
3521
3522 EXAMPLE
3523 @verbatim
3524 SELECT * FROM t1 NATURAL LEFT JOIN t2
3525 <=>
3526 SELECT * FROM t1 LEFT JOIN t2 ON (t1.i=t2.i and t1.j=t2.j ... )
3527
3528 SELECT * FROM t1 NATURAL JOIN t2 WHERE <some_cond>
3529 <=>
3530 SELECT * FROM t1, t2 WHERE (t1.i=t2.i and t1.j=t2.j and <some_cond>)
3531
3532 SELECT * FROM t1 JOIN t2 USING(j) WHERE <some_cond>
3533 <=>
3534 SELECT * FROM t1, t2 WHERE (t1.j=t2.j and <some_cond>)
3535 @endverbatim
3536
3537 @param b Right join argument.
3538 */
3540
3541 /**
3542 Set granted privileges for a table.
3543
3544 Can be used when generating temporary tables that are also used in
3545 resolver process, such as when generating a UNION table
3546
3547 @param privilege Privileges granted for this table.
3548 */
3550 grant.privilege |= privilege;
3551 }
3552
3553 bool save_properties();
3554 void restore_properties();
3555
3556 /*
3557 List of tables local to a subquery or the top-level SELECT (used by
3558 SQL_I_List). Considers views as leaves (unlike 'next_leaf' below).
3559 Created at parse time in Query_block::add_table_to_list() ->
3560 table_list.link_in_list().
3561 */
3563 /* link in a global list of all queries tables */
3564 Table_ref *next_global{nullptr}, **prev_global{nullptr};
3565 const char *db{nullptr}, *table_name{nullptr}, *alias{nullptr};
3566 /*
3567 Target tablespace name: When creating or altering tables, this
3568 member points to the tablespace_name in the HA_CREATE_INFO struct.
3569 */
3571 char *option{nullptr}; /* Used by cache index */
3572
3573 /** Table level optimizer hints for this table. */
3575 /* Hints for query block of this table. */
3577
3578 void set_lock(const Lock_descriptor &descriptor) {
3579 m_lock_descriptor = descriptor;
3580 }
3581
3583
3585
3586 private:
3587 /**
3588 The members below must be kept aligned so that (1 << m_tableno) == m_map.
3589 A table that takes part in a join operation must be assigned a unique
3590 table number.
3591 */
3592 uint m_tableno{0}; ///< Table number within query block
3593 table_map m_map{0}; ///< Table map, derived from m_tableno
3594 /**
3595 If this table or join nest is the Y in "X [LEFT] JOIN Y ON C", this
3596 member points to C. May also be generated from JOIN ... USING clause.
3597 It may be modified only by permanent transformations (permanent = done
3598 once for all executions of a prepared statement).
3599 */
3602
3603 public:
3604 /*
3605 (Valid only for semi-join nests) Bitmap of tables that are within the
3606 semi-join (this is different from bitmap of all nest's children because
3607 tables that were pulled out of the semi-join nest remain listed as
3608 nest's children).
3609 */
3611
3612 /*
3613 During parsing - left operand of NATURAL/USING join where 'this' is
3614 the right operand. After parsing (this->natural_join == this) iff
3615 'this' represents a NATURAL or USING join operation. Thus after
3616 parsing 'this' is a NATURAL/USING join iff (natural_join != NULL).
3617 */
3619 /*
3620 True if 'this' represents a nested join that is a NATURAL JOIN.
3621 For one of the operands of 'this', the member 'natural_join' points
3622 to the other operand of 'this'.
3623 */
3624 bool is_natural_join{false};
3625 /* Field names in a USING clause for JOIN ... USING. */
3627 /*
3628 Explicitly store the result columns of either a NATURAL/USING join or
3629 an operand of such a join.
3630 */
3632 /* true if join_columns contains all columns of this table reference. */
3634
3635 /*
3636 List of nodes in a nested join tree, that should be considered as
3637 leaves with respect to name resolution. The leaves are: views,
3638 top-most nodes representing NATURAL/USING joins, subqueries, and
3639 base tables. All of these Table_ref instances contain a
3640 materialized list of columns. The list is local to a subquery.
3641 */
3643 /* Index names in a "... JOIN ... USE/IGNORE INDEX ..." clause. */
3645 TABLE *table{nullptr}; /* opened table */
3647 table_id{}; /* table id (from binlog) for opened table */
3648 /*
3649 Query_result for derived table to pass it from table creation to table
3650 filling procedure
3651 */
3653 /*
3654 Reference from aux_tables to local list entry of main select of
3655 multi-delete statement:
3656 delete t1 from t2,t1 where t1.a<'B' and t2.b=t1.b;
3657 here it will be reference of first occurrence of t1 to second (as you
3658 can see this lists can't be merged)
3659 */
3661
3662 /*
3663 Holds the function used as the table function
3664 */
3666
3667 /**
3668 If we've previously made an access path for “derived”, it is cached here.
3669 This is useful if we need to plan the query block twice (the hypergraph
3670 optimizer can do so, with and without in2exists predicates), both saving
3671 work and avoiding issues when we try to throw away the old items_to_copy
3672 for a new (identical) one.
3673 */
3676
3677 private:
3678 /// Sampling information.
3681
3683
3684 /**
3685 This field is set to non-null for derived tables and views. It points
3686 to the Query_expression representing the derived table/view.
3687 E.g. for a query
3688 @verbatim SELECT * FROM (SELECT a FROM t1) b @endverbatim
3689 */
3690 Query_expression *derived{nullptr}; /* Query_expression of derived table */
3691
3692 /// If non-NULL, the CTE which this table is derived from.
3694 /**
3695 If the user has specified column names with the syntaxes "table name
3696 parenthesis column names":
3697 WITH qn(column names) AS (select...)
3698 or
3699 FROM (select...) dt(column names)
3700 or
3701 CREATE VIEW v(column_names) AS ...
3702 then this points to the list of column names. NULL otherwise.
3703 */
3705
3706 public:
3707 ST_SCHEMA_TABLE *schema_table{nullptr}; /* Information_schema table */
3709 /*
3710 True when the view field translation table is used to convert
3711 schema table fields for backwards compatibility with SHOW command.
3712 */
3714 /* link to query_block where this table was used */
3716
3717 private:
3718 LEX *view{nullptr}; /* link on VIEW lex for merging */
3719
3720 public:
3721 /// Array of selected expressions from a derived table or view.
3723
3724 /// pointer to element after last one in translation table above
3726 /*
3727 List (based on next_local) of underlying tables of this view. I.e. it
3728 does not include the tables of subqueries used in the view. Is set only
3729 for merged views.
3730 */
3732 /*
3733 - 0 for base tables
3734 - in case of the view it is the list of all (not only underlying
3735 tables but also used in subquery ones) tables of the view.
3736 */
3738 /* most upper view this table belongs to */
3740 /*
3741 The view directly referencing this table
3742 (non-zero only for merged underlying tables of a view).
3743 */
3745 /* Ptr to parent MERGE table list item. See top comment in ha_myisammrg.cc */
3747 /*
3748 Security context (non-zero only for tables which belong
3749 to view with SQL SECURITY DEFINER)
3750 */
3752 /*
3753 This view security context (non-zero only for views with
3754 SQL SECURITY DEFINER)
3755 */
3757 /*
3758 List of all base tables local to a subquery including all view
3759 tables. Unlike 'next_local', this in this list views are *not*
3760 leaves. Created in setup_tables() -> make_leaf_tables().
3761 */
3763 Item *derived_where_cond{nullptr}; ///< WHERE condition from derived table
3764 Item *check_option{nullptr}; ///< WITH CHECK OPTION condition
3765 Item *replace_filter{nullptr}; ///< Filter for REPLACE command
3766 LEX_STRING select_stmt{nullptr, 0}; ///< text of (CREATE/SELECT) statement
3767 LEX_STRING source{nullptr, 0}; ///< source of CREATE VIEW
3768 LEX_STRING timestamp{nullptr, 0}; ///< GMT time stamp of last operation
3769 LEX_USER definer; ///< definer of view
3770 void set_tablesample(tablesample_type sampling_type_arg,
3771 Item *sampling_percentage_arg) {
3772 sampling_type = sampling_type_arg;
3773 sampling_percentage = sampling_percentage_arg;
3774 }
3775
3776 bool has_tablesample() const {
3778 }
3779
3781
3782 double get_sampling_percentage() const;
3783
3785
3787
3788 /**
3789 @note: This field is currently not reliable when read from dictionary:
3790 If an underlying view is changed, updatable_view is not changed,
3791 due to lack of dependency checking in dictionary implementation.
3792 Prefer to use is_updatable() during preparation and optimization.
3793 */
3794 ulonglong updatable_view{0}; ///< VIEW can be updated
3795 /**
3796 @brief The declared algorithm, if this is a view.
3797 @details One of
3798 - VIEW_ALGORITHM_UNDEFINED
3799 - VIEW_ALGORITHM_TEMPTABLE
3800 - VIEW_ALGORITHM_MERGE
3801 @todo Replace with an enum
3802 */
3804 ulonglong view_suid{0}; ///< view is suid (true by default)
3805 ulonglong with_check{0}; ///< WITH CHECK OPTION
3806
3807 private:
3808 /// The view algorithm that is actually used, if this is a view.
3811
3812 public:
3814
3815 public:
3816 /// True if right argument of LEFT JOIN; false in other cases (i.e. if left
3817 /// argument of LEFT JOIN, if argument of INNER JOIN; RIGHT JOINs are
3818 /// converted to LEFT JOIN during contextualization).
3819 bool outer_join{false};
3820 /// True if was originally the left argument of a RIGHT JOIN, before we
3821 /// made it the right argument of a LEFT JOIN.
3823 uint shared{0}; /* Used in multi-upd */
3824 size_t db_length{0};
3826
3827 private:
3828 /// True if VIEW/TABLE is updatable, based on analysis of query (SQL rules).
3829 bool m_updatable{false};
3830 /// True if VIEW/TABLE is insertable, based on analysis of query (SQL rules).
3831 bool m_insertable{false};
3832 /// True if table is target of UPDATE statement, or updated in IODKU stmt.
3833 bool m_updated{false};
3834 /// True if table is target of INSERT statement.
3835 bool m_inserted{false};
3836 /// True if table is target of DELETE statement, or deleted in REPLACE stmt.
3837 bool m_deleted{false};
3838 bool m_fulltext_searched{false}; ///< True if fulltext searched
3839 public:
3840 bool straight{false}; /* optimize with prev table */
3841 /**
3842 True for tables and views being changed in a data change statement.
3843 Also true for tables subject to a SELECT ... FOR UPDATE.
3844 Also used by replication to filter out statements that can be ignored,
3845 especially important for multi-table UPDATE and DELETE.
3846 */
3847 bool updating{false};
3848 /// preload only non-leaf nodes (IS THIS USED???)
3849 bool ignore_leaves{false};
3850 /**
3851 The set of tables in the query block that this table depends on.
3852 Can be set due to outer join, join order hints or NOT EXISTS relationship.
3853 */
3855 /// The outer tables that an outer join's join condition depends on
3857 /**
3858 Is non-NULL if this table reference is a nested join, ie it represents
3859 the inner tables of an outer join, the tables contained in the
3860 parentheses of an inner join (eliminated during resolving), the tables
3861 referenced in a derived table or view, in a semi-join nest, the tables
3862 from the subquery.
3863 */
3865 /// The nested join containing this table reference.
3867 /// The join list immediately containing this table reference
3869 /// stop PS caching
3870 bool cacheable_table{false};
3871 /**
3872 Specifies which kind of table should be open for this element
3873 of table list.
3874 */
3876 /* true if this merged view contain auto_increment field */
3878 /// true <=> VIEW CHECK OPTION condition is processed (also for prep. stmts)
3880 /// true <=> Filter condition is processed
3882
3884 char timestamp_buffer[20]{0}; /* buffer for timestamp (19+1) */
3885 /*
3886 This Table_ref object is just placeholder for prelocking, it will be
3887 used for implicit LOCK TABLES only and won't be used in real statement.
3888 */
3890 /**
3891 Indicates that if Table_ref object corresponds to the table/view
3892 which requires special handling.
3893 */
3894 enum {
3895 /* Normal open. */
3897 /* Associate a table share only if the the table exists. */
3899 /*
3900 Associate a table share only if the the table exists.
3901 Also upgrade metadata lock to exclusive if table doesn't exist.
3902 */
3904 /* Don't associate a table share. */
3905 OPEN_STUB
3906 } open_strategy{OPEN_NORMAL};
3908 /** true if an alias for this table was specified in the SQL. */
3909 bool is_alias{false};
3910 /** true if the table is referred to in the statement using a fully
3911 qualified name (@<db_name@>.@<table_name@>).
3912 */
3913 bool is_fqtn{false};
3914 /**
3915 If true, this table is a derived (materialized) table which was created
3916 from a scalar subquery, cf.
3917 Query_block::transform_scalar_subqueries_to_join_with_derived
3918 */
3920
3921 /* View creation context. */
3922
3924
3925 /*
3926 Attributes to save/load view creation context in/from frm-file.
3927
3928 They are required only to be able to use existing parser to load
3929 view-definition file. As soon as the parser parsed the file, view
3930 creation context is initialized and the attributes become redundant.
3931
3932 These attributes MUST NOT be used for any purposes but the parsing.
3933 */
3934
3937
3938 /*
3939 View definition (SELECT-statement) in the UTF-form.
3940 */
3941
3943
3944 // True, If this is a system view
3945 bool is_system_view{false};
3946
3947 /*
3948 Set to 'true' if this is a DD table being opened in the context of a
3949 dictionary operation. Note that when 'false', this may still be a DD
3950 table when opened in a non-DD context, e.g. as part of an I_S view
3951 query.
3952 */
3953 bool is_dd_ctx_table{false};
3954
3955 /* End of view definition context. */
3956
3957 /* List of possible keys. Valid only for materialized derived tables/views. */
3959
3960 /**
3961 Indicates what triggers we need to pre-load for this Table_ref
3962 when opening an associated TABLE. This is filled after
3963 the parsed tree is created.
3964 */
3967
3969
3970 /// if true, EXPLAIN can't explain view due to insufficient rights.
3971 bool view_no_explain{false};
3972
3973 /* List to carry partition names from PARTITION (...) clause in statement */
3975
3976 /// Set table number
3978 assert(tableno < MAX_TABLES);
3980 m_map = (table_map)1 << tableno;
3981 }
3982 /// Return table number
3983 uint tableno() const { return m_tableno; }
3984
3985 /// Return table map derived from table number
3986 table_map map() const {
3987 assert(((table_map)1 << m_tableno) == m_map);
3988 return m_map;
3989 }
3990
3991 /// If non-NULL, the CTE which this table is derived from.
3994 /// @see m_derived_column_names
3997 }
4000 }
4001
4002 private:
4003 /*
4004 A group of members set and used only during JOIN::optimize().
4005 */
4006 /**
4007 Optimized copy of m_join_cond (valid for one single
4008 execution). Initialized by Query_block::get_optimizable_conditions().
4009 */
4011
4012 public:
4013 COND_EQUAL *cond_equal{nullptr}; ///< Used with outer join
4014 /// true <=> this table is a const one and was optimized away.
4015
4016 bool optimized_away{false};
4017 /**
4018 true <=> all possible keys for a derived table were collected and
4019 could be re-used while statement re-execution.
4020 */
4021
4023
4024 private:
4025 /// If a recursive reference inside the definition of a CTE.
4027 // End of group for optimization
4028
4029 /** See comments for set_metadata_id() */
4031 /** See comments for TABLE_SHARE::get_table_ref_version() */
4033
4034 /*
4035 All members whose names are suffixed with "_saved" are duplicated in
4036 class TABLE but actually belong in this class. They are saved from class
4037 TABLE when preparing a statement and restored when executing the statement.
4038 They are not required for a regular (non-prepared) statement.
4039 */
4045 bool nullable_saved{false};
4053};
4054
4055/*
4056 Iterator over the fields of a generic table reference.
4057*/
4058
4060 public:
4061 virtual ~Field_iterator() = default;
4062 virtual void set(Table_ref *) = 0;
4063 virtual void next() = 0;
4064 virtual bool end_of_fields() = 0; /* Return 1 at end of list */
4065 virtual const char *name() = 0;
4066 virtual Item *create_item(THD *) = 0;
4067 virtual Field *field() = 0;
4068};
4069
4070/*
4071 Iterator over the fields of a base table, view with temporary
4072 table, or subquery.
4073*/
4074
4077
4078 public:
4080 void set(Table_ref *table) override { ptr = table->table->field; }
4081 void set_table(TABLE *table) { ptr = table->field; }
4082 void next() override { ptr++; }
4083 bool end_of_fields() override { return *ptr == nullptr; }
4084 const char *name() override;
4085 Item *create_item(THD *thd) override;
4086 Field *field() override { return *ptr; }
4087};
4088
4089/**
4090 Iterator over the fields of a merged derived table or view.
4091*/
4092
4096
4097 public:
4099 void set(Table_ref *table) override;
4100 void next() override { ptr++; }
4101 bool end_of_fields() override { return ptr == array_end; }
4102 const char *name() override;
4103 Item *create_item(THD *thd) override;
4104 Item **item_ptr() { return &ptr->item; }
4105 Field *field() override { return nullptr; }
4106 inline Item *item() { return ptr->item; }
4108};
4109
4110/*
4111 Field_iterator interface to the list of materialized fields of a
4112 NATURAL/USING join.
4113*/
4114
4118
4119 public:
4121 ~Field_iterator_natural_join() override = default;
4122 void set(Table_ref *table) override;
4123 void next() override;
4124 bool end_of_fields() override { return !cur_column_ref; }
4125 const char *name() override { return cur_column_ref->name(); }
4126 Item *create_item(THD *thd) override {
4127 return cur_column_ref->create_item(thd);
4128 }
4129 Field *field() override { return cur_column_ref->field(); }
4131};
4132
4133/**
4134 Generic iterator over the fields of an arbitrary table reference.
4135
4136 This class unifies the various ways of iterating over the columns
4137 of a table reference depending on the type of SQL entity it
4138 represents. If such an entity represents a nested table reference,
4139 this iterator encapsulates the iteration over the columns of the
4140 members of the table reference.
4141
4142 The implementation assumes that all underlying NATURAL/USING table
4143 references already contain their result columns and are linked into
4144 the list Table_ref::next_name_resolution_table.
4145*/
4146
4153 void set_field_iterator();
4154
4155 public:
4157 void set(Table_ref *table) override;
4158 void next() override;
4159 bool end_of_fields() override {
4160 return (table_ref == last_leaf && field_it->end_of_fields());
4161 }
4162 const char *name() override { return field_it->name(); }
4163 const char *get_table_name();
4164 const char *get_db_name();
4165 GRANT_INFO *grant();
4166 Item *create_item(THD *thd) override { return field_it->create_item(thd); }
4167 Field *field() override { return field_it->field(); }
4169 Table_ref *parent_table_ref);
4171};
4172
4175 char *db, *table;
4177};
4178
4180 MY_BITMAP *bitmap) {
4181 my_bitmap_map *old = bitmap->bitmap;
4182 bitmap->bitmap = table->s->all_set.bitmap; // does not repoint last_word_ptr
4183 return old;
4184}
4185
4186static inline void tmp_restore_column_map(MY_BITMAP *bitmap,
4187 my_bitmap_map *old) {
4188 bitmap->bitmap = old;
4189}
4190
4191/* The following is only needed for debugging */
4192
4194 [[maybe_unused]],
4195 MY_BITMAP *bitmap
4196 [[maybe_unused]]) {
4197#ifndef NDEBUG
4198 return tmp_use_all_columns(table, bitmap);
4199#else
4200 return nullptr;
4201#endif
4202}
4203
4204static inline void dbug_tmp_restore_column_map(MY_BITMAP *bitmap
4205 [[maybe_unused]],
4206 my_bitmap_map *old
4207 [[maybe_unused]]) {
4208#ifndef NDEBUG
4209 tmp_restore_column_map(bitmap, old);
4210#endif
4211}
4212
4213/*
4214 Variant of the above : handle both read and write sets.
4215 Provide for the possibility of the read set being the same as the write set
4216*/
4217static inline void dbug_tmp_use_all_columns(
4218 TABLE *table [[maybe_unused]], my_bitmap_map **save [[maybe_unused]],
4219 MY_BITMAP *read_set [[maybe_unused]],
4220 MY_BITMAP *write_set [[maybe_unused]]) {
4221#ifndef NDEBUG
4222 save[0] = read_set->bitmap;
4223 save[1] = write_set->bitmap;
4224 (void)tmp_use_all_columns(table, read_set);
4225 (void)tmp_use_all_columns(table, write_set);
4226#endif
4227}
4228
4230 MY_BITMAP *read_set [[maybe_unused]], MY_BITMAP *write_set [[maybe_unused]],
4231 my_bitmap_map **old [[maybe_unused]]) {
4232#ifndef NDEBUG
4233 tmp_restore_column_map(read_set, old[0]);
4234 tmp_restore_column_map(write_set, old[1]);
4235#endif
4236}
4237
4238void init_mdl_requests(Table_ref *table_list);
4239
4240/**
4241 Unpacks the definition of a value generator in all its forms: generated
4242 column, default expression or checked constraint.
4243 The function parses the text definition of this expression, resolves its
4244 items and runs validation and calculates the base_columns_map which is used
4245 for tracking the columns the expression depends on.
4246
4247 @param[in] thd Thread handler
4248 @param[in] table Table having the value generator to be unpacked
4249 @param[in,out] val_generator Contains the expression in string format, and,
4250 if successful will be replaced by the parser
4251 with a new one having the unpacked expression.
4252 @param[in] source Source of value generator(a generated column,
4253 a regular column with generated default value or
4254 a check constraint).
4255 @param[in] source_name Name of the source (generated column, a regular
4256 column with generated default value or a check
4257 constraint).
4258 @param[in] field The column the value generator depends on. Can
4259 be null for checked constraints which do not
4260 depend on a single column.
4261 @param[in] is_create_table Indicates that table is opened as part
4262 of CREATE or ALTER and does not yet exist in SE
4263 @param[out] error_reported updated flag for the caller that no other error
4264 messages are to be generated.
4265
4266 @retval true Failure.
4267 @retval false Success.
4268*/
4269
4271 Value_generator **val_generator,
4273 const char *source_name, Field *field,
4274 bool is_create_table, bool *error_reported);
4275
4276/**
4277 Unpack the partition expression. Parse the partition expression
4278 to produce an Item.
4279
4280 @param[in] thd Thread handler
4281 @param[in] outparam Table object
4282 @param[in] share TABLE_SHARE object
4283 @param[in] engine_type Engine type of the partitions.
4284 @param[in] is_create_table Indicates that table is opened as part of
4285 CREATE or ALTER and does not yet exist in SE
4286
4287 @retval true Failure.
4288 @retval false Success.
4289*/
4290
4291bool unpack_partition_info(THD *thd, TABLE *outparam, TABLE_SHARE *share,
4292 handlerton *engine_type, bool is_create_table);
4293
4294int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias,
4295 uint db_stat, uint prgflag, uint ha_open_flags,
4296 TABLE *outparam, bool is_create_table,
4297 const dd::Table *table_def_param);
4298TABLE_SHARE *alloc_table_share(const char *db, const char *table_name,
4299 const char *key, size_t key_length,
4300 bool open_secondary);
4301void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key,
4302 size_t key_length, const char *table_name,
4303 const char *path, MEM_ROOT *mem_root);
4304void free_table_share(TABLE_SHARE *share);
4306Ident_name_check check_db_name(const char *name, size_t length);
4308 bool preserve_lettercase);
4309bool check_column_name(const Name_string &namestring);
4310Ident_name_check check_table_name(const char *name, size_t length);
4311int rename_file_ext(const char *from, const char *to, const char *ext);
4312char *get_field(MEM_ROOT *mem, Field *field);
4313bool get_field(MEM_ROOT *mem, Field *field, class String *res);
4314
4315int closefrm(TABLE *table, bool free_share);
4316void free_blobs(TABLE *table);
4318int set_zone(int nr, int min_zone, int max_zone);
4319void append_unescaped(String *res, const char *pos, size_t length);
4320char *fn_rext(char *name);
4322 const LEX_CSTRING &name);
4323
4324/* performance schema */
4326
4329
4330/* information schema */
4332
4333/* mysql schema name and DD ID */
4335static const uint MYSQL_SCHEMA_DD_ID = 1;
4336
4337/* mysql tablespace name and DD ID */
4339static const uint MYSQL_TABLESPACE_DD_ID = 1;
4340
4341/* replication's tables */
4345
4346inline bool is_infoschema_db(const char *name, size_t len) {
4347 return (
4350}
4351
4352inline bool is_infoschema_db(const char *name) {
4354}
4355
4356inline bool is_perfschema_db(const char *name, size_t len) {
4357 return (PERFORMANCE_SCHEMA_DB_NAME.length == len &&
4359 name));
4360}
4361
4362inline bool is_perfschema_db(const char *name) {
4364 name);
4365}
4366
4367/**
4368 Check if the table belongs to the P_S, excluding setup and threads tables.
4369
4370 @note Performance Schema tables must be accessible independently of the
4371 LOCK TABLE mode. This function is needed to handle the special case
4372 of P_S tables being used under LOCK TABLE mode.
4373*/
4374inline bool belongs_to_p_s(Table_ref *tl) {
4375 return (!strcmp("performance_schema", tl->db) &&
4376 strcmp(tl->table_name, "threads") &&
4377 strstr(tl->table_name, "setup_") == nullptr);
4378}
4379
4380/**
4381 return true if the table was created explicitly.
4382*/
4384 const char *name = table->s->table_name.str;
4386}
4387
4388bool is_simple_order(ORDER *order);
4389
4390uint add_pk_parts_to_sk(KEY *sk, uint sk_n, KEY *pk, uint pk_n,
4391 TABLE_SHARE *share, handler *handler_file,
4392 uint *usable_parts, bool use_extended_sk);
4393void setup_key_part_field(TABLE_SHARE *share, handler *handler_file,
4394 uint primary_key_n, KEY *keyinfo, uint key_n,
4395 uint key_part_n, uint *usable_parts,
4396 bool part_of_key_not_extended);
4397
4398const uchar *get_field_name(const uchar *arg, size_t *length);
4399
4400void repoint_field_to_record(TABLE *table, uchar *old_rec, uchar *new_rec);
4403 uint active_index = MAX_KEY);
4404
4405/**
4406 Check if a Table_ref instance represents a pre-opened temporary table.
4407*/
4408
4409inline bool is_temporary_table(const Table_ref *tl) {
4410 if (tl->is_view() || tl->schema_table) return false;
4411
4412 if (!tl->table) return false;
4413
4414 /*
4415 NOTE: 'table->s' might be NULL for specially constructed TABLE
4416 instances. See SHOW TRIGGERS for example.
4417 */
4418
4419 if (!tl->table->s) return false;
4420
4421 return tl->table->s->tmp_table != NO_TMP_TABLE;
4422}
4423
4424/**
4425 After parsing, a Common Table Expression is accessed through a
4426 Table_ref. This class contains all information about the CTE which the
4427 Table_ref needs.
4428
4429 @note that before and during parsing, the CTE is described by a
4430 PT_common_table_expr.
4431*/
4433 public:
4436 TABLE *clone_tmp_table(THD *thd, Table_ref *tl);
4438 /// Remove one table reference.
4439 void remove_table(Table_ref *tr);
4440 /// Empties the materialized CTE and informs all of its clones.
4441 bool clear_all_references();
4442 /**
4443 All references to this CTE in the statement, except those inside the
4444 query expression defining this CTE.
4445 In other words, all non-recursive references.
4446 */
4448 /// True if it's a recursive CTE
4450 /**
4451 List of all TABLE_LISTSs reading/writing to the tmp table created to
4452 materialize this CTE. Due to shared materialization, only the first one
4453 has a TABLE generated by create_tmp_table(); other ones have a TABLE
4454 generated by open_table_from_share().
4455 */
4457 /// Name of the WITH block. Used only for EXPLAIN FORMAT=tree.
4459};
4460
4461/**
4462 This iterates on those references to a derived table / view / CTE which are
4463 materialized. If a recursive CTE, this includes recursive references.
4464 Upon construction it is passed a non-recursive materialized reference
4465 to the derived table (Table_ref*).
4466 For a CTE it may return more than one reference; for a derived table or a
4467 view, there is only one (as references to a same view are treated as
4468 independent objects).
4469 References are returned as TABLE*.
4470*/
4472 Table_ref *const start; ///< The reference provided in construction.
4473 size_t ref_idx{0}; ///< Current index in cte->tmp_tables
4474 bool m_is_first{true}; ///< True when at first reference in list
4475 public:
4476 explicit Derived_refs_iterator(Table_ref *start_arg) : start(start_arg) {}
4479 m_is_first = ref_idx == 0;
4480 // Derived tables and views have a single reference.
4481 if (cte == nullptr) {
4482 return ref_idx++ == 0 ? start->table : nullptr;
4483 }
4484 /*
4485 CTEs may have multiple references. Return the next one, but notice that
4486 some references may have been deleted.
4487 */
4488 while (ref_idx < cte->tmp_tables.size()) {
4489 TABLE *table = cte->tmp_tables[ref_idx++]->table;
4490 if (table != nullptr) return table;
4491 }
4492 return nullptr;
4493 }
4494 void rewind() {
4495 ref_idx = 0;
4496 m_is_first = true;
4497 }
4498 /// @returns true if the last get_next() returned the first element.
4499 bool is_first() const {
4500 // Call after get_next() has been called:
4501 assert(ref_idx > 0);
4502 return m_is_first;
4503 }
4504};
4505
4506/**
4507 RAII class to reset TABLE::autoinc_field_has_explicit_non_null_value after
4508 processing individual row in INSERT or LOAD DATA statements.
4509*/
4511 public:
4513 : m_table(table) {}
4516 }
4517
4518 private:
4520};
4521
4522// Whether we can ask the storage engine for the row ID of the last row read.
4523//
4524// Some operations needs a row ID to operate correctly (i.e. weedout). Normally,
4525// the row ID is provided by the storage engine by calling handler::position().
4526// But there are cases when position() should not be called:
4527//
4528// 1. If we have a const table (rows are fetched during optimization), we
4529// should not call position().
4530// 2. If we have a NULL-complemented row, calling position() would give a
4531// random row ID back, as there has not been any row read.
4532//
4533// Operations that needs the row ID must also check the value of
4534// QEP_TAB::rowid_status to see whether they actually need a row ID.
4535// See QEP_TAB::rowid_status for more details.
4536inline bool can_call_position(const TABLE *table) {
4537 return !table->const_table && !(table->is_nullable() && table->null_row);
4538}
4539
4540//////////////////////////////////////////////////////////////////////////
4541
4542/*
4543 NOTE:
4544 These structures are added to read .frm file in upgrade scenario.
4545
4546 They should not be used any where else in the code.
4547 They will be removed in future release.
4548 Any new code should not be added in this section.
4549*/
4550
4551/**
4552 These members were removed from TABLE_SHARE as they are not used in
4553 in the code. open_binary_frm() uses these members while reading
4554 .frm files.
4555*/
4557 public:
4560 null_field_first(false),
4561 stored_fields(0),
4563 frm_version(0),
4564 fieldnames() {}
4565
4568 uint stored_fields; /* Number of stored fields
4569 (i.e. without generated-only ones) */
4570
4571 enum utype {
4584 EMPTY_VAL, // EMPTY_VAL rather than EMPTY since EMPTY can conflict with
4585 // system headers.
4597 GENERATED_FIELD = 128
4599
4600 /**
4601 For shares representing views File_parser object with view
4602 definition read from .FRM file.
4603 */
4606 TYPELIB fieldnames; /* Pointer to fieldnames */
4607};
4608
4609/**
4610 Create TABLE_SHARE from .frm file.
4611
4612 FRM_context object is used to store the value removed from
4613 TABLE_SHARE. These values are used only for .frm file parsing.
4614
4615 @param[in] thd Thread handle.
4616 @param[in] path Path of the frm file.
4617 @param[out] share TABLE_SHARE to be populated.
4618 @param[out] frm_context FRM_context object.
4619 @param[in] db Database name.
4620 @param[in] table Table name.
4621 @param[in] is_fix_view_cols_and_deps Fix view column data, table
4622 and routine dependency.
4623
4624 @retval 0 ON SUCCESS
4625 @retval -1 ON FAILURE
4626 @retval -2 ON LESS SEVER FAILURE (see read_frm_file)
4627*/
4628int create_table_share_for_upgrade(THD *thd, const char *path,
4629 TABLE_SHARE *share, FRM_context *frm_context,
4630 const char *db, const char *table,
4631 bool is_fix_view_cols_and_deps);
4632//////////////////////////////////////////////////////////////////////////
4633
4634/**
4635 Create a copy of the key_info from TABLE_SHARE object to TABLE object.
4636
4637 Wherever prefix key is present, allocate a new Field object, having its
4638 field_length set to the prefix key length, and point the table's matching
4639 key_part->field to this new Field object.
4640
4641 This ensures that unpack_partition_info() reads the correct prefix length of
4642 partitioned fields
4643
4644 @param table Table for which key_info is to be allocated
4645 @param root MEM_ROOT in which to allocate key_info
4646
4647 @retval false Success
4648 @retval true Failed to allocate memory for table.key_info in root
4649*/
4650
4652
4653#endif /* TABLE_INCLUDED */
uint32_t Access_bitmask
Definition: auth_acls.h:34
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
int64 query_id_t
Definition: binlog.h:72
Per internal schema ACL access rules.
Definition: auth_common.h:147
Per internal table ACL access rules.
Definition: auth_common.h:109
RAII class to reset TABLE::autoinc_field_has_explicit_non_null_value after processing individual row ...
Definition: table.h:4510
Autoinc_field_has_explicit_non_null_value_reset_guard(TABLE *table)
Definition: table.h:4512
~Autoinc_field_has_explicit_non_null_value_reset_guard()
Definition: table.h:4514
Class that represents a single change to a column value in partial update of a JSON column.
Definition: table.h:1324
const char * old_data(const Field *field) const
Get a pointer to the start of the old data to be replaced.
Definition: table.cc:7785
size_t length() const
Definition: table.h:1345
size_t m_length
The size of the portion that is to be replaced.
Definition: table.h:1329
const char * new_data(const Field *field) const
Get a pointer to the start of the replacement data.
Definition: table.cc:7776
Binary_diff(size_t offset, size_t length)
Create a new Binary_diff object.
Definition: table.h:1338
size_t m_offset
The offset of the start of the change.
Definition: table.h:1326
size_t offset() const
Definition: table.h:1342
Definition: sql_bitmap.h:154
Class is used as a BLOB field value storage for intermediate GROUP_CONCAT results.
Definition: table.h:1284
bool truncated_value
Sign that some values were cut during saving into the storage.
Definition: table.h:1291
Blob_mem_storage()
Definition: table.cc:4100
void reset()
Definition: table.h:1297
void set_truncated_value(bool is_truncated_value)
Definition: table.h:1314
MEM_ROOT storage
Definition: table.h:1286
~Blob_mem_storage()
Definition: table.cc:4104
bool is_truncated_value() const
Definition: table.h:1317
char * store(const char *from, size_t length)
Function creates duplicate of 'from' string in 'storage' MEM_ROOT.
Definition: table.h:1311
Definition: item_cmpfunc.h:2734
After parsing, a Common Table Expression is accessed through a Table_ref.
Definition: table.h:4432
Common_table_expr(MEM_ROOT *mem_root)
Definition: table.h:4434
LEX_STRING name
Name of the WITH block. Used only for EXPLAIN FORMAT=tree.
Definition: table.h:4458
TABLE * clone_tmp_table(THD *thd, Table_ref *tl)
Produces, from the first tmp TABLE object, a clone TABLE object for Table_ref 'tl',...
Definition: sql_derived.cc:170
bool clear_all_references()
Empties the materialized CTE and informs all of its clones.
Definition: sql_union.cc:1605
bool recursive
True if it's a recursive CTE.
Definition: table.h:4449
Mem_root_array< Table_ref * > references
All references to this CTE in the statement, except those inside the query expression defining this C...
Definition: table.h:4447
void remove_table(Table_ref *tr)
Remove one table reference.
Definition: sql_derived.cc:259
bool substitute_recursive_reference(THD *thd, Query_block *sl)
Replaces the recursive reference in query block 'sl' with a clone of the first tmp table.
Definition: sql_derived.cc:246
Mem_root_array< Table_ref * > tmp_tables
List of all TABLE_LISTSs reading/writing to the tmp table created to materialize this CTE.
Definition: table.h:4456
API for getting cost estimates for server operations that are not directly related to a table object.
Definition: opt_costmodel.h:54
API for getting cost estimates for operations on table data.
Definition: opt_costmodel.h:242
void init(const Cost_model_server *cost_model_server, const TABLE *table)
Initializes the cost model object.
Definition: opt_costmodel.cc:68
Default_object_creation_ctx – default implementation of Object_creation_ctx.
Definition: table.h:226
const CHARSET_INFO * get_client_cs()
Definition: table.h:228
void change_env(THD *thd) const override
Definition: table.cc:220
void delete_backup_ctx() override
Definition: table.cc:218
Default_object_creation_ctx(THD *thd)
Definition: table.cc:205
const CHARSET_INFO * get_connection_cl()
Definition: table.h:230
Object_creation_ctx * create_backup_ctx(THD *thd) const override
Definition: table.cc:213
const CHARSET_INFO * m_connection_cl
connection_cl stores the value of collation_connection session variable.
Definition: table.h:264
const CHARSET_INFO * m_client_cs
client_cs stores the value of character_set_client session variable.
Definition: table.h:254
This structure is used to keep info about possible key for the result table of a derived table/view.
Definition: table.h:2823
table_map referenced_by
Definition: table.h:2825
Field_map used_fields
Definition: table.h:2826
uint key_part_count
Definition: table.h:2827
This iterates on those references to a derived table / view / CTE which are materialized.
Definition: table.h:4471
bool is_first() const
Definition: table.h:4499
TABLE * get_next()
Definition: table.h:4477
Table_ref *const start
The reference provided in construction.
Definition: table.h:4472
Derived_refs_iterator(Table_ref *start_arg)
Definition: table.h:4476
bool m_is_first
True when at first reference in list.
Definition: table.h:4474
size_t ref_idx
Current index in cte->tmp_tables.
Definition: table.h:4473
void rewind()
Definition: table.h:4494
These members were removed from TABLE_SHARE as they are not used in in the code.
Definition: table.h:4556
utype
Definition: table.h:4571
@ CASEUP
Definition: table.h:4576
@ NO
Definition: table.h:4581
@ NONE
Definition: table.h:4572
@ REL
Definition: table.h:4582
@ NEXT_NUMBER
Definition: table.h:4588
@ DATE
Definition: table.h:4573
@ PNR
Definition: table.h:4577
@ BIT_FIELD
Definition: table.h:4590
@ TIMESTAMP_OLD_FIELD
Definition: table.h:4591
@ GENERATED_FIELD
Definition: table.h:4597
@ INTERVAL_FIELD
Definition: table.h:4589
@ TIMESTAMP_UN_FIELD
Definition: table.h:4595
@ NOEMPTY
Definition: table.h:4575
@ CHECK
Definition: table.h:4583
@ YES
Definition: table.h:4580
@ TIMESTAMP_DNUN_FIELD
Definition: table.h:4596
@ BLOB_FIELD
Definition: table.h:4593
@ UNKNOWN_FIELD
Definition: table.h:4586
@ CASEDN
Definition: table.h:4587
@ TIMESTAMP_DN_FIELD
Definition: table.h:4594
@ PGNR
Definition: table.h:4579
@ EMPTY_VAL
Definition: table.h:4584
@ CAPITALIZE
Definition: table.h:4592
@ SHIELD
Definition: table.h:4574
@ BGNR
Definition: table.h:4578
bool null_field_first
Definition: table.h:4567
uchar frm_version
Definition: table.h:4605
handlerton * default_part_db_type
Definition: table.h:4566
TYPELIB fieldnames
Definition: table.h:4606
const File_parser * view_def
For shares representing views File_parser object with view definition read from .FRM file.
Definition: table.h:4604
uint stored_fields
Definition: table.h:4568
FRM_context()
Definition: table.h:4558
Definition: table.h:4115
~Field_iterator_natural_join() override=default
Natural_join_column * column_ref()
Definition: table.h:4130
void next() override
Definition: table.cc:5160
void set(Table_ref *table) override
Definition: table.cc:5154
Natural_join_column * cur_column_ref
Definition: table.h:4117
Field_iterator_natural_join()
Definition: table.h:4120
const char * name() override
Definition: table.h:4125
List_iterator_fast< Natural_join_column > column_ref_it
Definition: table.h:4116
bool end_of_fields() override
Definition: table.h:4124
Item * create_item(THD *thd) override
Definition: table.h:4126
Field * field() override
Definition: table.h:4129
Generic iterator over the fields of an arbitrary table reference.
Definition: table.h:4147
Field_iterator * field_it
Definition: table.h:4152
Field_iterator_view view_field_it
Definition: table.h:4150
Table_ref * table_ref
Definition: table.h:4148
const char * get_table_name()
Definition: table.cc:5233
Field * field() override
Definition: table.h:4167
const char * get_db_name()
Definition: table.cc:5240
Field_iterator_table_ref()
Definition: table.h:4156
void set(Table_ref *table) override
Definition: table.cc:5210
Natural_join_column * get_or_create_column_ref(THD *thd, Table_ref *parent_table_ref)
Create new or return existing column reference to a column of a natural/using join.
Definition: table.cc:5301
Table_ref * first_leaf
Definition: table.h:4148
GRANT_INFO * grant()
Definition: table.cc:5260
void next() override
Definition: table.cc:5219
Field_iterator_table table_field_it
Definition: table.h:4149
Table_ref * last_leaf
Definition: table.h:4148
const char * name() override
Definition: table.h:4162
Natural_join_column * get_natural_column_ref()
Return an existing reference to a column of a natural/using join.
Definition: table.cc:5381
void set_field_iterator()
Definition: table.cc:5167
Item * create_item(THD *thd) override
Definition: table.h:4166
bool end_of_fields() override
Definition: table.h:4159
Field_iterator_natural_join natural_join_it
Definition: table.h:4151
Definition: table.h:4075
const char * name() override
Definition: table.cc:5077
Field ** ptr
Definition: table.h:4076
Item * create_item(THD *thd) override
Definition: table.cc:5079
void set_table(TABLE *table)
Definition: table.h:4081
void next() override
Definition: table.h:4082
Field_iterator_table()
Definition: table.h:4079
bool end_of_fields() override
Definition: table.h:4083
void set(Table_ref *table) override
Definition: table.h:4080
Field * field() override
Definition: table.h:4086
Iterator over the fields of a merged derived table or view.
Definition: table.h:4093
void next() override
Definition: table.h:4100
Item * item()
Definition: table.h:4106
Table_ref * view
Definition: table.h:4095
Field_iterator_view()
Definition: table.h:4098
Field_translator * field_translator()
Definition: table.h:4107
Item ** item_ptr()
Definition: table.h:4104
void set(Table_ref *table) override
Definition: table.cc:5070
Field * field() override
Definition: table.h:4105
Field_translator * array_end
Definition: table.h:4094
Item * create_item(THD *thd) override
Definition: table.cc:5097
const char * name() override
Definition: table.cc:5095
Field_translator * ptr
Definition: table.h:4094
bool end_of_fields() override
Definition: table.h:4101
Definition: table.h:4059
virtual const char * name()=0
virtual Field * field()=0
virtual void next()=0
virtual void set(Table_ref *)=0
virtual ~Field_iterator()=default
virtual Item * create_item(THD *)=0
virtual bool end_of_fields()=0
A field that stores a JSON value.
Definition: field.h:4002
Definition: field.h:2402
Definition: field.h:575
Definition: parse_file.h:87
Definition: sql_auth_cache.h:475
Base class to be used by handlers different shares.
Definition: handler.h:4115
Intrusive parameterized list.
Definition: sql_plist.h:75
Definition: sql_lex.h:489
Definition: item.h:4345
A wrapper Item that normally returns its parameter, but becomes NULL when processing rows for rollup.
Definition: item_func.h:1679
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
Query optimization plan node.
Definition: sql_select.h:602
Vector of logical diffs describing changes to a JSON column.
Definition: json_diff.h:141
A path expression which can be used to seek to a position inside a JSON value.
Definition: json_path.h:298
Abstraction for accessing JSON values irrespective of whether they are (started out as) binary JSON v...
Definition: json_dom.h:1153
Definition: key.h:57
Definition: key.h:113
ulong flags
dupp key and pack flags
Definition: key.h:118
Definition: sql_list.h:627
Definition: sql_list.h:467
Context of the owner of metadata locks.
Definition: mdl.h:1412
A pending metadata lock request.
Definition: mdl.h:802
void set_type(enum_mdl_type type_arg)
Set type of lock request.
Definition: mdl.h:853
A granted metadata lock.
Definition: mdl.h:985
An abstract class for inspection of a connected subgraph of the wait-for graph.
Definition: mdl.h:920
Abstract class representing an edge in the waiters graph to be traversed by deadlock detection algori...
Definition: mdl.h:946
A typesafe replacement for DYNAMIC_ARRAY.
Definition: mem_root_array.h:426
Storage for name strings.
Definition: item.h:292
Definition: table.h:2587
Item * create_item(THD *thd)
Definition: table.cc:5031
Item_field * table_field
Definition: table.h:2590
Field_translator * view_field
Definition: table.h:2589
Natural_join_column(Field_translator *field_param, Table_ref *tab)
Definition: table.cc:4999
const char * name()
Definition: table.cc:5022
Table_ref * table_ref
Definition: table.h:2591
bool is_common
Definition: table.h:2599
const char * db_name()
Definition: table.cc:5054
GRANT_INFO * grant()
Definition: table.cc:5068
Field * field()
Definition: table.cc:5041
const char * table_name()
Definition: table.cc:5049
Object_creation_ctx – interface for creation context of database objects (views, stored routines,...
Definition: table.h:202
void restore_env(THD *thd, Object_creation_ctx *backup_ctx)
Definition: table.cc:193
Object_creation_ctx()=default
virtual Object_creation_ctx * create_backup_ctx(THD *thd) const =0
virtual void change_env(THD *thd) const =0
virtual void delete_backup_ctx()=0
virtual ~Object_creation_ctx()=default
Object_creation_ctx * set_n_backup(THD *thd)
Definition: table.cc:183
Query block level hints.
Definition: opt_hints.h:377
Table level hints.
Definition: opt_hints.h:554
Definition: sql_executor.h:254
uint index() const
Definition: sql_opt_exec_shared.h:522
This class represents a query block, aka a query specification, which is a query consisting of a SELE...
Definition: sql_lex.h:1167
This class represents a query expression (one query block or several query blocks combined with UNION...
Definition: sql_lex.h:626
Definition: sql_union.h:40
This class represents a buffer that can be used for multi-row reads.
Definition: record_buffer.h:47
A set of THD members describing the current authenticated user.
Definition: sql_security_ctx.h:54
Definition: sql_sort.h:156
An adapter that takes in another RowIterator and produces the same rows, just in sorted order.
Definition: sorting_iterator.h:56
Class to represent check constraint in the TABLE_SHARE.
Definition: sql_check_constraint.h:110
Class to represent check constraint in the TABLE instance.
Definition: sql_check_constraint.h:145
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Element that represents the table in the specific table cache.
Definition: table_cache.h:231
Definition: table.h:607
Table_check_intact()
Definition: table.h:613
bool has_keys
Definition: table.h:609
virtual void report_error(uint code, const char *fmt,...)=0
bool check(THD *thd, TABLE *table, const TABLE_FIELD_DEF *table_def)
Checks whether a table is intact.
Definition: table.cc:3767
virtual ~Table_check_intact()=default
Class representing a table function.
Definition: table_function.h:53
The Table_histograms_collection manages a collection of reference-counted snapshots of histogram stat...
Definition: table_histograms.h:239
The Table_histograms class represents a snapshot of the collection of histograms associated with a ta...
Definition: table_histograms.h:145
Definition: table.h:2865
bool m_inserted
True if table is target of INSERT statement.
Definition: table.h:3835
LEX_STRING view_body_utf8
Definition: table.h:3942
bool force_index_group_saved
Definition: table.h:4048
bool view_no_explain
if true, EXPLAIN can't explain view due to insufficient rights.
Definition: table.h:3971
Common_table_expr * m_common_table_expr
If non-NULL, the CTE which this table is derived from.
Definition: table.h:3693
bool is_base_table() const
Definition: table.h:3148
bool m_is_sj_or_aj_nest
Definition: table.h:3601
const char * get_table_name() const
Returns the name of the table that this Table_ref represents.
Definition: table.h:3432
Key_map keys_in_use_for_group_by_saved
Definition: table.h:4043
List< String > * join_using_fields
Definition: table.h:3626
void set_privileges(Access_bitmask privilege)
Set granted privileges for a table.
Definition: table.h:3549
Item * derived_where_cond
WHERE condition from derived table.
Definition: table.h:3763
char timestamp_buffer[20]
Definition: table.h:3884
bool process_index_hints(const THD *thd, TABLE *table)
Compiles the tagged hints list and fills up TABLE::keys_in_use_for_query, TABLE::keys_in_use_for_grou...
Definition: table.cc:6385
MY_BITMAP read_set_saved
Definition: table.h:4050
bool is_updatable() const
Return true if table is updatable.
Definition: table.h:3222
ulonglong with_check
WITH CHECK OPTION.
Definition: table.h:3805
void set_lock(const Lock_descriptor &descriptor)
Definition: table.h:3578
Table_ref(TABLE *table_arg, const char *alias_arg)
This constructor can be used when a Table_ref is needed for an existing temporary table.
Definition: table.h:2913
Lock_descriptor m_lock_descriptor
Definition: table.h:3810
bool prepare_replace_filter(THD *thd)
Prepare replace filter for a view (used for REPLACE command)
Definition: table.cc:4722
bool can_push_condition_to_derived(THD *thd)
Check if we can push outer where condition to this derived table.
Definition: sql_derived.cc:1082
COND_EQUAL * cond_equal
Used with outer join.
Definition: table.h:4013
bool materializable_is_const(THD *thd) const
Checks if this is a table that contains zero rows or one row, and that can be materialized during opt...
Definition: table.cc:6536
bool setup_table_function(THD *thd)
Setup a table function to use materialization.
Definition: sql_derived.cc:998
bool is_aj_nest() const
Definition: table.h:3058
table_map sj_inner_tables
Definition: table.h:3610
LEX * view_query() const
Return the valid LEX object for a view.
Definition: table.h:3328
Table_ref * first_leaf_table()
Return first leaf table of a base table or a view/derived table.
Definition: table.h:3296
table_map m_map
Table map, derived from m_tableno.
Definition: table.h:3593
const Create_col_name_list * derived_column_names() const
Definition: table.h:3995
Table_ref * first_leaf_for_name_resolution()
Retrieve the first (left-most) leaf in a nested join tree with respect to name resolution.
Definition: table.cc:4860
const Create_col_name_list * m_derived_column_names
If the user has specified column names with the syntaxes "table name parenthesis column names": WITH ...
Definition: table.h:3704
Field_translator * field_translation
Array of selected expressions from a derived table or view.
Definition: table.h:3722
bool join_order_swapped
True if was originally the left argument of a RIGHT JOIN, before we made it the right argument of a L...
Definition: table.h:3822
Table_ref(TABLE *table_arg, const char *db_name_arg, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, const char *alias_arg, enum thr_lock_type lock_type_arg)
Creates a Table_ref object with pre-allocated strings for database, table and alias.
Definition: table.h:2885
bool is_multiple_tables() const
Return true if this is a view or derived table that is defined over more than one base table,...
Definition: table.h:3282
ulonglong m_table_ref_version
See comments for TABLE_SHARE::get_table_ref_version()
Definition: table.h:4032
Table_ref * outer_join_nest() const
Returns the outer join nest that this Table_ref belongs to, if any.
Definition: table.h:3466
bool has_tablesample() const
Definition: table.h:3776
double sampling_percentage_val
Definition: table.h:3682
void set_updatable()
Set table as updatable. (per default, a table is non-updatable)
Definition: table.h:3225
bool prepare_security(THD *thd)
Prepare security context for a view.
Definition: table.cc:4976
void set_deleted()
Set table and all referencing views as being deleted from.
Definition: table.h:3255
bool check_option_processed
true <=> VIEW CHECK OPTION condition is processed (also for prep. stmts)
Definition: table.h:3879
bool check_single_table(Table_ref **table_ref, table_map map)
Check which single table inside a view that matches a table map.
Definition: table.cc:4788
bool is_external() const
Is this table only available in an external storage engine?
Definition: table.cc:7342
void set_derived_query_expression(Query_expression *query_expr)
Set the query expression of a derived table or view.
Definition: table.h:3337
Query_block * schema_query_block
Definition: table.h:3708
ST_SCHEMA_TABLE * schema_table
Definition: table.h:3707
enum_table_ref_type m_table_ref_type
See comments for set_metadata_id()
Definition: table.h:4030
ulonglong updatable_view
VIEW can be updated.
Definition: table.h:3794
table_map map() const
Return table map derived from table number.
Definition: table.h:3986
Item * m_join_cond
If this table or join nest is the Y in "X [LEFT] JOIN Y ON C", this member points to C.
Definition: table.h:3600
bool cacheable_table
stop PS caching
Definition: table.h:3870
bool is_derived_unfinished_materialization() const
Definition: table.cc:7332
void set_derived_column_names(const Create_col_name_list *d)
Definition: table.h:3998
Table_ref * embedding
The nested join containing this table reference.
Definition: table.h:3866
bool is_placeholder() const
Definition: table.h:3174
bool schema_table_filled
Definition: table.h:3966
void set_updated()
Set table and all referencing views as being updated.
Definition: table.h:3237
void set_uses_materialization()
Set table to be materialized.
Definition: table.h:3214
Table_ref(const char *db_name, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, const char *alias_arg, enum thr_lock_type lock_type_arg, enum enum_mdl_type mdl_request_type)
Definition: table.h:3002
Field_translator * field_translation_end
pointer to element after last one in translation table above
Definition: table.h:3725
Security_context * find_view_security_context(THD *thd)
Find security context of current view.
Definition: table.cc:4945
Key_map merge_keys_saved
Definition: table.h:4041
bool setup_materialized_derived_tmp_table(THD *thd)
Sets up the tmp table to contain the derived table's rows.
Definition: sql_derived.cc:874
mem_root_deque< Table_ref * > * join_list
The join list immediately containing this table reference.
Definition: table.h:3868
bool is_mergeable() const
Return true if view or derived table and can be merged.
Definition: table.cc:6517
mem_root_deque< Table_ref * > * view_tables
Definition: table.h:3737
uint m_tableno
The members below must be kept aligned so that (1 << m_tableno) == m_map.
Definition: table.h:3592
void print(const THD *thd, String *str, enum_query_type query_type) const
Produce a textual identification of this object.
Definition: sql_lex.cc:2932
@ OPEN_IF_EXISTS
Definition: table.h:3898
@ OPEN_STUB
Definition: table.h:3905
@ OPEN_FOR_CREATE
Definition: table.h:3903
Table_ref * referencing_view
Definition: table.h:3744
void set_fulltext_searched()
Set table as full-text search (default is not fulltext searched)
Definition: table.h:3261
Table_ref * correspondent_table
Definition: table.h:3660
bool is_view() const
Return true if this represents a named view.
Definition: table.h:3127
List< Natural_join_column > * join_columns
Definition: table.h:3631
int view_check_option(THD *thd) const
Evaluate the check option of a view.
Definition: table.cc:4765
const char * get_db_name() const
Returns the name of the database that the referenced table belongs to.
Definition: table.h:3424
bool updating
True for tables and views being changed in a data change statement.
Definition: table.h:3847
bool m_insertable
True if VIEW/TABLE is insertable, based on analysis of query (SQL rules).
Definition: table.h:3831
void set_readonly()
Set table as readonly, ie it is neither updatable, insertable nor deletable during this statement.
Definition: table.h:3273
bool is_updated() const
Return true if table is being updated.
Definition: table.h:3234
bool m_updatable
True if VIEW/TABLE is updatable, based on analysis of query (SQL rules).
Definition: table.h:3829
void set_tableno(uint tableno)
Set table number.
Definition: table.h:3977
enum_view_algorithm effective_algorithm
The view algorithm that is actually used, if this is a view.
Definition: table.h:3809
bool is_inner_table_of_outer_join() const
Return true if this table is an inner table of some outer join.
Definition: table.h:3481
Table_ref * belong_to_view
Definition: table.h:3739
LEX * view
Definition: table.h:3718
bool set_insert_values(MEM_ROOT *mem_root)
Allocate a buffer for inserted column values.
Definition: table.cc:4809
MY_BITMAP read_set_internal_saved
Definition: table.h:4052
bool is_derived() const
Return true if this represents a derived table (an unnamed view)
Definition: table.h:3130
bool derived_keys_ready
true <=> all possible keys for a derived table were collected and could be re-used while statement re...
Definition: table.h:4022
const Table_ref * updatable_base_table() const
Return the base table entry of an updatable table.
Definition: table.h:3494
void restore_properties()
Restore persistent properties into TABLE from Table_ref.
Definition: table.cc:4493
Table_ref ** prev_global
Definition: table.h:3564
Query_block * query_block
Definition: table.h:3715
const Table_ref * top_table() const
Return the outermost view this table belongs to, or itself.
Definition: table.h:3108
void set_merged()
Set table to be merged.
Definition: table.h:3203
void set_insertable()
Set table as insertable-into. (per default, a table is not insertable)
Definition: table.h:3231
uint tableno() const
Return table number.
Definition: table.h:3983
size_t db_length
Definition: table.h:3824
List< Index_hint > * index_hints
Definition: table.h:3644
LEX_STRING select_stmt
text of (CREATE/SELECT) statement
Definition: table.h:3766
Table_ref(const char *db_name_arg, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, const char *alias_arg, enum thr_lock_type lock_type_arg)
Definition: table.h:3018
bool is_natural_join
Definition: table.h:3624
Query_expression * derived
This field is set to non-null for derived tables and views.
Definition: table.h:3690
MY_BITMAP lock_partitions_saved
Definition: table.h:4049
bool is_fulltext_searched() const
Returns true if a MATCH function references this table.
Definition: table.h:3264
Table_ref * natural_join
Definition: table.h:3618
bool outer_join
True if right argument of LEFT JOIN; false in other cases (i.e.
Definition: table.h:3819
Table_ref * parent_l
Definition: table.h:3746
bool is_table_function() const
Return true if this represents a table function.
Definition: table.h:3136
bool m_updated
True if table is target of UPDATE statement, or updated in IODKU stmt.
Definition: table.h:3833
bool optimized_away
true <=> this table is a const one and was optimized away.
Definition: table.h:4016
bool is_insertable() const
Return true if table is insertable-into.
Definition: table.h:3228
AccessPath * access_path_for_derived
If we've previously made an access path for “derived”, it is cached here.
Definition: table.h:3674
bool is_alias
true if an alias for this table was specified in the SQL.
Definition: table.h:3909
Table_ref()=default
bool straight
Definition: table.h:3840
int fetch_number_of_rows(ha_rows fallback_estimate=PLACEHOLDER_TABLE_ROW_ESTIMATE)
Retrieve number of rows in the table.
Definition: table.cc:6582
void set_join_cond(Item *val)
Definition: table.h:3039
bool is_system_view
Definition: table.h:3945
uint8 trg_event_map
Indicates what triggers we need to pre-load for this Table_ref when opening an associated TABLE.
Definition: table.h:3965
Table_ref * last_leaf_for_name_resolution()
Retrieve the last (right-most) leaf in a nested join tree with respect to name resolution.
Definition: table.cc:4876
bool schema_table_reformed
Definition: table.h:3713
bool is_sj_or_aj_nest() const
Definition: table.h:3060
Key_map keys_in_use_for_query_saved
Definition: table.h:4042
MY_BITMAP write_set_saved
Definition: table.h:4051
List< String > * partition_names
Definition: table.h:3974
bool force_index_order_saved
Definition: table.h:4047
Query_expression * derived_query_expression() const
Return the query expression of a derived table or view.
Definition: table.h:3342
bool ignore_leaves
preload only non-leaf nodes (IS THIS USED???)
Definition: table.h:3849
Table_ref * next_leaf
Definition: table.h:3762
bool is_leaf_for_name_resolution() const
Test if this is a leaf with respect to name resolution.
Definition: table.cc:4837
Table_ref * next_local
Definition: table.h:3562
Table_ref * merge_underlying_list
Definition: table.h:3731
LEX_CSTRING target_tablespace_name
Definition: table.h:3570
dd::enum_table_type required_type
Definition: table.h:3883
static Table_ref * new_nested_join(MEM_ROOT *allocator, const char *alias, Table_ref *embedding, mem_root_deque< Table_ref * > *belongs_to, Query_block *select)
Create a Table_ref object representing a nested join.
Definition: table.cc:4365
bool m_was_scalar_subquery
If true, this table is a derived (materialized) table which was created from a scalar subquery,...
Definition: table.h:3919
bool is_recursive_reference() const
Definition: table.h:3145
GRANT_INFO grant
Definition: table.h:3813
Table_ref * top_table()
Definition: table.h:3112
bool is_table_ref_id_equal(TABLE_SHARE *s) const
Compare the version of metadata from the previous execution (if any) with values obtained from the cu...
Definition: table.h:3386
void set_sj_or_aj_nest()
Makes the next a semi/antijoin nest.
Definition: table.h:3062
bool validate_tablesample_clause(THD *thd)
Definition: table.cc:7356
void set_table_ref_id(enum_table_ref_type table_ref_type_arg, ulonglong table_ref_version_arg)
Definition: table.h:3401
void set_tablesample(tablesample_type sampling_type_arg, Item *sampling_percentage_arg)
Definition: table.h:3770
bool is_internal() const
Definition: table.h:3164
bool prepare_view_security_context(THD *thd)
Load security context information for this view.
Definition: table.cc:4900
const Lock_descriptor & lock_descriptor() const
Definition: table.h:3582
bool nullable_saved
Definition: table.h:4045
NESTED_JOIN * nested_join
Is non-NULL if this table reference is a nested join, ie it represents the inner tables of an outer j...
Definition: table.h:3864
Table_ref(TABLE *table_arg, const char *alias_arg, enum_mdl_type mdl_type)
Sets an explicit enum_mdl_type value, without initializing m_lock_descriptor.
Definition: table.h:2930
const char * db
Definition: table.h:3565
Security_context * security_ctx
Definition: table.h:3751
bool is_inserted() const
Return true if table is being inserted into.
Definition: table.h:3243
Table_ref(const char *db_name, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, enum thr_lock_type lock_type_arg, enum enum_mdl_type mdl_request_type)
Definition: table.h:2957
bool materialize_derived(THD *thd)
Materialize derived table.
Definition: sql_derived.cc:1754
Security_context * view_sctx
Definition: table.h:3756
bool merge_where(THD *thd)
Merge WHERE condition of view or derived table into outer query.
Definition: table.cc:4529
ulonglong view_suid
view is suid (true by default)
Definition: table.h:3804
ulonglong algorithm
The declared algorithm, if this is a view.
Definition: table.h:3803
enum Table_ref::@190 OPEN_NORMAL
Indicates that if Table_ref object corresponds to the table/view which requires special handling.
uint get_hidden_field_count_for_derived() const
Return the number of hidden fields added for the temporary table created for this derived table.
Definition: table.cc:7337
List< Derived_key > derived_key_list
Definition: table.h:3958
bool prepare_check_option(THD *thd, bool is_cascaded=false)
Prepare check option for a view.
Definition: table.cc:4663
void set_common_table_expr(Common_table_expr *c)
Definition: table.h:3993
Table_ref * next_global
Definition: table.h:3564
bool optimize_derived(THD *thd)
Optimize the query expression representing a derived table/view.
Definition: sql_derived.cc:1644
LEX_STRING timestamp
GMT time stamp of last operation.
Definition: table.h:3768
bool replace_filter_processed
true <=> Filter condition is processed
Definition: table.h:3881
tablesample_type sampling_type
Sampling information.
Definition: table.h:3679
Table_ref(const char *db_name, const char *table_name_arg, enum thr_lock_type lock_type_arg, enum enum_mdl_type mdl_request_type)
Definition: table.h:2942
mysql::binlog::event::Table_id table_id
Definition: table.h:3647
bool generate_keys()
Generate keys for a materialized derived table/view.
Definition: table.cc:6963
enum_open_type open_type
Specifies which kind of table should be open for this element of table list.
Definition: table.h:3875
Item * m_join_cond_optim
Optimized copy of m_join_cond (valid for one single execution).
Definition: table.h:4010
table_map join_cond_dep_tables
The outer tables that an outer join's join condition depends on.
Definition: table.h:3856
Table_ref * updatable_base_table()
Definition: table.h:3504
Item * replace_filter
Filter for REPLACE command.
Definition: table.h:3765
bool merge_underlying_tables(Query_block *select)
Merge tables from a query block into a nested join structure.
Definition: table.cc:4401
Common_table_expr * common_table_expr() const
If non-NULL, the CTE which this table is derived from.
Definition: table.h:3992
bool internal_tmp_table
Definition: table.h:3907
LEX_STRING source
source of CREATE VIEW
Definition: table.h:3767
bool update_sampling_percentage()
Definition: table.cc:7388
Table_ref(const char *db_name, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, enum thr_lock_type lock_type_arg)
Definition: table.h:2973
LEX_CSTRING view_connection_cl_name
Definition: table.h:3936
bool has_stored_program() const
Definition: table.cc:6531
LEX_CSTRING view_client_cs_name
Definition: table.h:3935
bool save_properties()
Save persistent properties from TABLE into Table_ref.
Definition: table.cc:4462
bool is_join_columns_complete
Definition: table.h:3633
bool m_is_recursive_reference
If a recursive reference inside the definition of a CTE.
Definition: table.h:4026
bool is_deleted() const
Return true if table is being deleted from.
Definition: table.h:3252
bool prelocking_placeholder
Definition: table.h:3889
LEX_USER definer
definer of view
Definition: table.h:3769
const char * table_name
Definition: table.h:3565
Item * sampling_percentage
Definition: table.h:3675
uint shared
Definition: table.h:3823
Item ** join_cond_optim_ref()
Definition: table.h:3053
bool create_field_translation(THD *thd)
Create field translation for merged derived table/view.
Definition: table.cc:4566
bool create_materialized_table(THD *thd)
Create result table for a materialized derived table/view.
Definition: sql_derived.cc:1692
uint query_block_id_for_explain() const
This is for showing in EXPLAIN.
Definition: table.cc:6330
Opt_hints_table * opt_hints_table
Table level optimizer hints for this table.
Definition: table.h:3574
tablesample_type get_sampling_type() const
Definition: table.h:3786
bool setup_materialized_derived(THD *thd)
Setup a derived table to use materialization.
Definition: sql_derived.cc:862
Table_ref * any_outer_leaf_table()
Return any leaf table that is not an inner table of an outer join.
Definition: table.h:3307
View_creation_ctx * view_creation_ctx
Definition: table.h:3923
char * option
Definition: table.h:3571
double get_sampling_percentage() const
Definition: table.cc:7404
Table_ref(const char *db_name, size_t db_length_arg, const char *table_name_arg, size_t table_name_length_arg, const char *alias_arg, enum enum_mdl_type mdl_request_type)
Sets an explicit enum_mdl_type value, without initializing m_lock_descriptor.
Definition: table.h:2988
TABLE * table
Definition: table.h:3645
void set_view_query(LEX *lex)
Set the LEX object of a view (will also define this as a view).
Definition: table.h:3325
void set_inserted()
Set table and all referencing views as being inserted into.
Definition: table.h:3246
bool update_derived_keys(THD *, Field *, Item **, uint, bool *)
Update derived table's list of possible keys.
Definition: table.cc:6903
uint query_block_id() const
If a derived table, returns query block id of first underlying query block.
Definition: table.cc:6325
bool m_fulltext_searched
True if fulltext searched.
Definition: table.h:3838
Item * join_cond() const
Definition: table.h:3038
Table_ref * next_name_resolution_table
Definition: table.h:3642
bool is_view_or_derived() const
Return true if this represents a named view or a derived table.
Definition: table.h:3133
bool is_merged() const
Return true if this is a derived table or view that is merged.
Definition: table.h:3200
void set_join_cond_optim(Item *cond)
Definition: table.h:3045
table_map dep_tables
The set of tables in the query block that this table depends on.
Definition: table.h:3854
size_t table_name_length
Definition: table.h:3825
bool uses_materialization() const
Return true if this is a materializable derived table/view.
Definition: table.h:3209
void add_join_natural(Table_ref *b)
Mark that there is a NATURAL JOIN or JOIN ... USING between two tables.
Definition: table.h:3539
bool is_sj_nest() const
Definition: table.h:3056
bool contain_auto_increment
Definition: table.h:3877
bool resolve_derived(THD *thd, bool apply_semijoin)
Resolve a derived table or view reference.
Definition: sql_derived.cc:273
Key_map covering_keys_saved
Definition: table.h:4040
uint leaf_tables_count() const
Return no. of base tables a merged view or derived table is defined over.
Definition: table.cc:6550
const char * alias
Definition: table.h:3565
Item * join_cond_optim() const
Definition: table.h:3044
bool set_recursive_reference()
Definition: table.cc:7325
Opt_hints_qb * opt_hints_qb
Definition: table.h:3576
bool is_dd_ctx_table
Definition: table.h:3953
Table_ref(TABLE *table_arg)
Only to be used by legacy code that temporarily needs a Table_ref, more specifically: Query_result_cr...
Definition: table.h:2873
bool is_fqtn
true if the table is referred to in the statement using a fully qualified name (<db_name>.
Definition: table.h:3913
bool force_index_saved
Definition: table.h:4046
Table_ref(const char *db_name, const char *table_name, enum thr_lock_type lock_type)
Constructor that can be used when the strings are null terminated.
Definition: table.h:2876
Item ** join_cond_ref()
Definition: table.h:3037
Key_map keys_in_use_for_order_by_saved
Definition: table.h:4044
Table_function * table_function
Definition: table.h:3665
bool m_deleted
True if table is target of DELETE statement, or deleted in REPLACE stmt.
Definition: table.h:3837
MDL_request mdl_request
Definition: table.h:3968
Table_ref(const char *db_name, const char *table_name, const char *alias, enum thr_lock_type lock_type)
Constructor that can be used when the strings are null terminated.
Definition: table.h:2901
Item * check_option
WITH CHECK OPTION condition.
Definition: table.h:3764
Query_result_union * derived_result
Definition: table.h:3652
void set_table_ref_id(TABLE_SHARE *s)
Record the value of metadata version of the corresponding table definition cache element in this pars...
Definition: table.h:3397
void reset()
Reset table.
Definition: table.cc:4416
This class holds all information about triggers of a table.
Definition: table_trigger_dispatcher.h:63
Object containing parameters used when creating and using temporary tables.
Definition: temp_table_param.h:95
Used for storing information associated with generated column, default values generated from expressi...
Definition: field.h:483
View_creation_ctx – creation context of view objects.
Definition: table.h:271
static View_creation_ctx * create(THD *thd)
Definition: table.cc:231
View_creation_ctx(THD *thd)
Definition: table.h:278
Class representing the fact that some thread waits for table share to be flushed.
Definition: table.h:637
MDL_context * m_ctx
Definition: table.h:638
Wait_for_flush ** prev_in_share
Definition: table.h:659
Wait_for_flush * next_in_share
Pointers for participating in the list of waiters for table share.
Definition: table.h:658
TABLE_SHARE * m_share
Definition: table.h:639
MDL_context * get_ctx() const
Definition: table.h:649
uint m_deadlock_weight
Definition: table.h:640
bool accept_visitor(MDL_wait_for_graph_visitor *dvisitor) override
Traverse portion of wait-for graph which is reachable through edge represented by this flush ticket i...
Definition: table.cc:3905
Wait_for_flush(MDL_context *ctx_arg, TABLE_SHARE *share_arg, uint deadlock_weight_arg)
Definition: table.h:643
uint get_deadlock_weight() const override
Definition: table.cc:3909
enum_rule
Definition: foreign_key.h:54
Definition: table.h:47
Definition: view.h:39
The handler class is the interface for dynamically loadable storage engines.
Definition: handler.h:4571
@ NONE
Definition: handler.h:4657
enum handler::@57 inited
Histogram base class.
Definition: histogram.h:314
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
Each table share has a table id, it is mainly used for row based replication.
Definition: table_id.h:42
Definition: partition_info.h:209
A table definition from the master.
Definition: rpl_utility.h:248
static MEM_ROOT mem_root
Definition: client_plugin.cc:114
enum_query_type
Query type constants (usable as bitmap flags).
Definition: enum_query_type.h:31
Value_generator_source
Enum to indicate source for which value generator is used.
Definition: field.h:473
This file contains the field type.
enum_field_types
Column types for MySQL Note: Keep include/mysql/components/services/bits/stored_program_bits....
Definition: field_types.h:55
void * memdup_root(MEM_ROOT *root, const void *str, size_t len)
Definition: my_alloc.cc:296
struct PSI_table_share PSI_table_share
Definition: psi_table_bits.h:100
static void free_share(st_blackhole_share *share)
Definition: ha_blackhole.cc:308
static int flag
Definition: hp_test1.cc:40
static uint keys
Definition: hp_test2.cc:49
enum_json_diff_operation
Enum that describes what kind of operation a Json_diff object represents.
Definition: json_diff.h:52
float rec_per_key_t
Data type for records per key estimates that are stored in the KEY::rec_per_key_float[] array.
Definition: key.h:96
enum_order
Definition: key_spec.h:65
@ ORDER_NOT_RELEVANT
Definition: key_spec.h:65
constexpr const LEX_CSTRING EMPTY_CSTR
Definition: lex_string.h:48
constexpr const LEX_CSTRING NULL_CSTR
Definition: lex_string.h:47
A better implementation of the UNIX ctype(3) library.
int my_strcasecmp(const CHARSET_INFO *cs, const char *s1, const char *s2)
Definition: m_ctype.h:653
MYSQL_PLUGIN_IMPORT CHARSET_INFO * system_charset_info
Definition: mysqld.cc:1543
#define MDL_REQUEST_INIT(R, P1, P2, P3, P4, P5)
Definition: mdl.h:906
@ MDL_TRANSACTION
Locks with transaction duration are automatically released at the end of transaction.
Definition: mdl.h:343
This file follows Google coding style, except for the name MEM_ROOT (which is kept for historical rea...
This file includes constants used by all storage engines.
#define HA_VIRTUAL_GEN_KEY
Set if a key is on any virtual generated columns.
Definition: my_base.h:553
ulong key_part_map
Definition: my_base.h:1008
my_off_t ha_rows
Definition: my_base.h:1141
#define HA_POS_ERROR
Definition: my_base.h:1143
ha_storage_media
Definition: my_base.h:116
@ HA_SM_DEFAULT
Definition: my_base.h:117
uint32 my_bitmap_map
Definition: my_bitmap.h:41
Header for compiler-dependent features.
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
uint8_t uint8
Definition: my_inttypes.h:63
unsigned char uchar
Definition: my_inttypes.h:52
int64_t int64
Definition: my_inttypes.h:68
uint16_t uint16
Definition: my_inttypes.h:65
uint32_t uint32
Definition: my_inttypes.h:67
Common header for many mysys elements.
uint64_t table_map
Definition: my_table_map.h:30
#define NAME_CHAR_LEN
Field/table name length.
Definition: mysql_com.h:60
ABI for instrumented mutexes.
static char * path
Definition: mysqldump.cc:149
std::string str(const mysqlrouter::ConfigGenerator::Options::Endpoint &ep)
Definition: config_generator.cc:1086
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: buf0block_hint.cc:30
const std::string charset("charset")
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:43
enum_table_type
Definition: abstract_table.h:53
Definition: os0file.h:89
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
Definition: column_statistics.h:34
Json_data_extension ext
Definition: backend.cc:52
size_t size(const char *const c)
Definition: base64.h:46
const char * table_name
Definition: rules_table_service.cc:56
const char * db_name
Definition: rules_table_service.cc:55
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2893
Performance schema instrumentation interface.
required string key
Definition: replication_asynchronous_connection_failover.proto:60
required uint32 status
Definition: replication_asynchronous_connection_failover.proto:61
repeated Source source
Definition: replication_asynchronous_connection_failover.proto:42
enum_stats_auto_recalc
Definition: handler.h:3193
row_type
Definition: handler.h:684
void free_blobs(TABLE *table)
Definition: table.cc:3375
LEX_CSTRING SLOW_LOG_NAME
Definition: table.cc:152
bool update_generated_write_fields(const MY_BITMAP *bitmap, TABLE *table)
Calculate data for each generated field marked for write in the corresponding column map.
Definition: table.cc:7260
I_P_List< Wait_for_flush, I_P_List_adapter< Wait_for_flush, &Wait_for_flush::next_in_share, &Wait_for_flush::prev_in_share > > Wait_for_flush_list
Definition: table.h:666
enum_open_type
Type of table which can be open for an element of table list.
Definition: table.h:2808
@ OT_TEMPORARY_OR_BASE
Definition: table.h:2809
@ OT_TEMPORARY_ONLY
Definition: table.h:2810
@ OT_BASE_ONLY
Definition: table.h:2811
static my_bitmap_map * tmp_use_all_columns(TABLE *table, MY_BITMAP *bitmap)
Definition: table.h:4179
int64 query_id_t
Definition: table.h:141
bool unpack_value_generator(THD *thd, TABLE *table, Value_generator **val_generator, Value_generator_source source, const char *source_name, Field *field, bool is_create_table, bool *error_reported)
Unpacks the definition of a value generator in all its forms: generated column, default expression or...
Definition: table.cc:2588
static void tmp_restore_column_map(MY_BITMAP *bitmap, my_bitmap_map *old)
Definition: table.h:4186
static void empty_record(TABLE *table)
Definition: table.h:2489
bool assert_invalid_stats_is_locked(const TABLE *)
Assert that caller holds lock on the table cache when TABLE::m_invalid_stats is accessed.
Definition: table.cc:8111
static my_bitmap_map * dbug_tmp_use_all_columns(TABLE *table, MY_BITMAP *bitmap)
Definition: table.h:4193
char * fn_rext(char *name)
Returns pointer to '.frm' extension of the file name.
Definition: table.cc:306
bool is_simple_order(ORDER *order)
Test if the order list consists of simple field expressions.
Definition: table.cc:7103
LEX_CSTRING MYSQL_SCHEMA_NAME
Definition: table.cc:143
enum enum_mdl_type mdl_type_for_dml(enum thr_lock_type lock_type)
Derive type of metadata lock to be requested for table used by a DML statement from the type of THR_L...
Definition: table.h:2797
bool create_key_part_field_with_prefix_length(TABLE *table, MEM_ROOT *root)
Create a copy of the key_info from TABLE_SHARE object to TABLE object.
Definition: table.cc:2810
bool is_user_table(TABLE *table)
return true if the table was created explicitly.
Definition: table.h:4383
bool assert_invalid_dict_is_locked(const TABLE *)
Assert that LOCK_thd_data is held when TABLE::m_invalid_dict is accessed.
Definition: table.cc:8098
void update_create_info_from_table(HA_CREATE_INFO *info, TABLE *form)
Definition: table.cc:3542
enum_view_algorithm
Strategy for how to process a view or derived table (merge or materialization)
Definition: table.h:2545
@ VIEW_ALGORITHM_TEMPTABLE
Definition: table.h:2547
@ VIEW_ALGORITHM_UNDEFINED
Definition: table.h:2546
@ VIEW_ALGORITHM_MERGE
Definition: table.h:2548
Mem_root_array_YY< LEX_CSTRING > Create_col_name_list
Definition: table.h:139
LEX_CSTRING MI_INFO_NAME
Definition: table.cc:158
bool is_infoschema_db(const char *name, size_t len)
Definition: table.h:4346
bool update_generated_read_fields(uchar *buf, TABLE *table, uint active_index=MAX_KEY)
Evaluate necessary virtual generated columns.
Definition: table.cc:7198
bool is_perfschema_db(const char *name, size_t len)
Definition: table.h:4356
Ident_name_check
Enumerate possible status of a identifier name while determining its validity.
Definition: table.h:191
Ident_name_check check_and_convert_db_name(LEX_STRING *db, bool preserve_lettercase)
Check if database name is valid, and convert to lower case if necessary.
Definition: table.cc:3670
LEX_CSTRING GENERAL_LOG_NAME
Definition: table.cc:149
const uchar * get_field_name(const uchar *arg, size_t *length)
LEX_CSTRING WORKER_INFO_NAME
Definition: table.cc:161
tmp_table_type
Definition: table.h:411
@ TRANSACTIONAL_TMP_TABLE
Definition: table.h:414
@ NON_TRANSACTIONAL_TMP_TABLE
Definition: table.h:413
@ INTERNAL_TMP_TABLE
Definition: table.h:415
@ NO_TMP_TABLE
Definition: table.h:412
@ SYSTEM_TMP_TABLE
Definition: table.h:416
int closefrm(TABLE *table, bool free_share)
Free information allocated by openfrm.
Definition: table.cc:3333
enum_table_category
Category of table found in the table share.
Definition: table.h:422
@ TABLE_CATEGORY_ACL_TABLE
A ACL metadata table.
Definition: table.h:590
@ TABLE_UNKNOWN_CATEGORY
Unknown value.
Definition: table.h:426
@ TABLE_CATEGORY_USER
User table.
Definition: table.h:461
@ TABLE_CATEGORY_RPL_INFO
Replication Information Tables.
Definition: table.h:558
@ TABLE_CATEGORY_INFORMATION
Information schema tables.
Definition: table.h:495
@ TABLE_CATEGORY_GTID
Gtid Table.
Definition: table.h:575
@ TABLE_CATEGORY_DICTIONARY
A data dictionary table.
Definition: table.h:583
@ TABLE_CATEGORY_PERFORMANCE
Performance schema tables.
Definition: table.h:539
@ TABLE_CATEGORY_LOG
Log tables.
Definition: table.h:517
@ TABLE_CATEGORY_SYSTEM
System table, maintained by the server.
Definition: table.h:473
@ TABLE_CATEGORY_TEMPORARY
Temporary table.
Definition: table.h:451
bool is_temporary_table(const Table_ref *tl)
Check if a Table_ref instance represents a pre-opened temporary table.
Definition: table.h:4409
enum_table_ref_type
Enumerate possible types of a table from re-execution standpoint.
Definition: table.h:178
@ TABLE_REF_VIEW
Definition: table.h:181
@ TABLE_REF_BASE_TABLE
Definition: table.h:182
@ TABLE_REF_I_S_TABLE
Definition: table.h:183
@ TABLE_REF_TMP_TABLE
Definition: table.h:184
@ TABLE_REF_NULL
Initial value set by the parser.
Definition: table.h:180
bool check_column_name(const Name_string &namestring)
Definition: table.cc:3736
#define STATUS_DELETED
Reserved for use by multi-table delete. Means the row has been deleted.
Definition: table.h:1395
TABLE_CATEGORY get_table_category(const LEX_CSTRING &db, const LEX_CSTRING &name)
Definition: table.cc:312
uint add_pk_parts_to_sk(KEY *sk, uint sk_n, KEY *pk, uint pk_n, TABLE_SHARE *share, handler *handler_file, uint *usable_parts, bool use_extended_sk)
Generate extended secondary keys by adding primary key parts to the existing secondary key.
Definition: table.cc:817
bool can_call_position(const TABLE *table)
Definition: table.h:4536
#define STATUS_UPDATED
Reserved for use by multi-table update. Means the row has been updated.
Definition: table.h:1388
#define tmp_file_prefix
Prefix for tmp tables.
Definition: table.h:158
Lex_acl_attrib_udyn
This is generic enum.
Definition: table.h:2616
static const uint MYSQL_SCHEMA_DD_ID
Definition: table.h:4335
Bitmap< MAX_FIELDS > Field_map
Definition: table.h:1401
index_hint_type
Definition: table.h:1398
@ INDEX_HINT_FORCE
Definition: table.h:1398
@ INDEX_HINT_IGNORE
Definition: table.h:1398
@ INDEX_HINT_USE
Definition: table.h:1398
int create_table_share_for_upgrade(THD *thd, const char *path, TABLE_SHARE *share, FRM_context *frm_context, const char *db, const char *table, bool is_fix_view_cols_and_deps)
Create TABLE_SHARE from .frm file.
Definition: table.cc:8004
void append_unescaped(String *res, const char *pos, size_t length)
Store an SQL quoted string.
Definition: table.cc:3505
Ident_name_check check_table_name(const char *name, size_t length)
Function to check if table name is valid or not.
Definition: table.cc:3709
char * get_field(MEM_ROOT *mem, Field *field)
Allocate string field in MEM_ROOT and return it as NULL-terminated string.
Definition: table.cc:3604
LEX_CSTRING MYSQL_TABLESPACE_NAME
Definition: table.cc:146
static const uint MYSQL_TABLESPACE_DD_ID
Definition: table.h:4339
#define STATUS_NOT_STARTED
Flags for TABLE::m_status (maximum 8 bits).
Definition: table.h:1380
void setup_key_part_field(TABLE_SHARE *share, handler *handler_file, uint primary_key_n, KEY *keyinfo, uint key_n, uint key_part_n, uint *usable_parts, bool part_of_key_not_extended)
Setup key-related fields of Field object for given key and key part.
Definition: table.cc:739
void init_tmp_table_share(THD *thd, TABLE_SHARE *share, const char *key, size_t key_length, const char *table_name, const char *path, MEM_ROOT *mem_root)
Initialize share for temporary tables.
Definition: table.cc:468
enum enum_table_category TABLE_CATEGORY
Definition: table.h:592
LEX_CSTRING INFORMATION_SCHEMA_NAME
Definition: table.cc:136
void init_mdl_requests(Table_ref *table_list)
Helper function which allows to allocate metadata lock request objects for all elements of table list...
Definition: table.cc:6505
struct Table_share_foreign_key_info TABLE_SHARE_FOREIGN_KEY_INFO
static void dbug_tmp_restore_column_maps(MY_BITMAP *read_set, MY_BITMAP *write_set, my_bitmap_map **old)
Definition: table.h:4229
void repoint_field_to_record(TABLE *table, uchar *old_rec, uchar *new_rec)
Repoint a table's fields from old_rec to new_rec.
Definition: table.cc:7118
#define PLACEHOLDER_TABLE_ROW_ESTIMATE
Definition: table.h:161
void free_blob_buffers_and_reset(TABLE *table, uint32 size)
Reclaims temporary blob storage which is bigger than a threshold.
Definition: table.cc:3396
bool unpack_partition_info(THD *thd, TABLE *outparam, TABLE_SHARE *share, handlerton *engine_type, bool is_create_table)
Unpack the partition expression.
Definition: table.cc:2718
#define STATUS_NOT_FOUND
Means we were searching for a row and didn't find it.
Definition: table.h:1386
int open_table_from_share(THD *thd, TABLE_SHARE *share, const char *alias, uint db_stat, uint prgflag, uint ha_open_flags, TABLE *outparam, bool is_create_table, const dd::Table *table_def_param)
Open a table based on a TABLE_SHARE.
Definition: table.cc:2887
LEX_CSTRING PERFORMANCE_SCHEMA_DB_NAME
Definition: table.cc:139
#define STATUS_NULL_ROW
Means that table->null_row is set.
Definition: table.h:1393
ulong refresh_version
Definition: mysqld.cc:1372
static void dbug_tmp_restore_column_map(MY_BITMAP *bitmap, my_bitmap_map *old)
Definition: table.h:4204
#define restore_record(A, B)
Definition: table.h:153
int set_zone(int nr, int min_zone, int max_zone)
Definition: table.cc:3487
Ident_name_check check_db_name(const char *name, size_t length)
Check if database name is valid.
Definition: table.cc:3634
int rename_file_ext(const char *from, const char *to, const char *ext)
Definition: table.cc:3561
TABLE_SHARE * alloc_table_share(const char *db, const char *table_name, const char *key, size_t key_length, bool open_secondary)
Allocate and setup a TABLE_SHARE structure.
Definition: table.cc:377
void free_table_share(TABLE_SHARE *share)
Free table share and memory used by it.
Definition: table.cc:608
bool belongs_to_p_s(Table_ref *tl)
Check if the table belongs to the P_S, excluding setup and threads tables.
Definition: table.h:4374
bool assert_ref_count_is_locked(const TABLE_SHARE *)
Assert that the LOCK_open mutex is held when the reference count of a TABLE_SHARE is accessed.
Definition: table.cc:520
#define tmp_file_prefix_length
Definition: table.h:159
LEX_CSTRING RLI_INFO_NAME
Definition: table.cc:155
struct Table_share_foreign_key_parent_info TABLE_SHARE_FOREIGN_KEY_PARENT_INFO
File containing constants that can be used throughout the server.
constexpr const unsigned int MAX_KEY
Definition: sql_const.h:45
constexpr const size_t MAX_TABLES
Max tables in join.
Definition: sql_const.h:107
enum_mark_columns
Definition: sql_const.h:230
enum_mdl_type
Type of metadata lock request.
Definition: sql_lexer_yacc_state.h:106
@ MDL_SHARED_WRITE
Definition: sql_lexer_yacc_state.h:179
@ MDL_SHARED_WRITE_LOW_PRIO
Definition: sql_lexer_yacc_state.h:185
@ MDL_SHARED_READ
Definition: sql_lexer_yacc_state.h:169
int plan_idx
This represents the index of a JOIN_TAB/QEP_TAB in an array.
Definition: sql_opt_exec_shared.h:54
static MEM_ROOT mem
Definition: sql_servers.cc:100
case opt name
Definition: sslopt-case.h:29
Access paths are a query planning structure that correspond 1:1 to iterators, in that an access path ...
Definition: access_path.h:213
Definition: m_ctype.h:423
Struct that describes an expression selected from a derived table or view.
Definition: table.h:2571
Item * item
Points to an item that represents the expression.
Definition: table.h:2576
const char * name
Name of selected expression.
Definition: table.h:2578
The current state of the privilege checking process for the current user, SQL statement and SQL objec...
Definition: table.h:370
GRANT_INTERNAL_INFO m_internal
The grant state for internal tables.
Definition: table.h:408
GRANT_INFO()
Definition: table.cc:282
Access_bitmask privilege
The set of privileges that the current user has fulfilled for a certain host, database,...
Definition: table.h:406
GRANT_TABLE * grant_table
A copy of the privilege information regarding the current host, database, object and user.
Definition: table.h:378
uint version
Used for cache invalidation when caching privilege information.
Definition: table.h:394
State information for internal tables grants.
Definition: table.h:347
bool m_table_lookup_done
True if the internal lookup by table name was done.
Definition: table.h:353
const ACL_internal_table_access * m_table_access
Cached internal table access.
Definition: table.h:355
bool m_schema_lookup_done
True if the internal lookup by schema name was done.
Definition: table.h:349
const ACL_internal_schema_access * m_schema_access
Cached internal schema access.
Definition: table.h:351
Struct to hold information about the table that should be created.
Definition: handler.h:3202
Hook class which via its methods specifies which members of T should be used for participating in a i...
Definition: sql_plist.h:198
Definition of name for generated keys, owned by TABLE_SHARE.
Definition: table.h:693
char name[NAME_CHAR_LEN]
Definition: table.h:694
Definition: table.h:2688
bool use_default_password_lifetime
Definition: table.h:2691
bool update_password_expired_column
Definition: table.h:2690
bool update_failed_login_attempts
Definition: table.h:2702
uint32 password_reuse_interval
Definition: table.h:2698
bool use_default_password_reuse_interval
Definition: table.h:2699
Lex_acl_attrib_udyn update_password_require_current
Definition: table.h:2706
uint failed_login_attempts
Definition: table.h:2701
bool update_password_reuse_interval
Definition: table.h:2700
bool update_password_history
Definition: table.h:2697
int password_lock_time
Definition: table.h:2703
bool update_account_locked_column
Definition: table.h:2693
bool update_password_expired_fields
Definition: table.h:2689
bool use_default_password_history
Definition: table.h:2696
bool update_password_lock_time
Definition: table.h:2704
bool account_locked
Definition: table.h:2694
void cleanup()
Definition: table.h:2707
uint16 expire_after_days
Definition: table.h:2692
uint32 password_history_length
Definition: table.h:2695
Definition: table.h:2623
bool modify_factor
Definition: table.h:2645
LEX_CSTRING generated_password
Definition: table.h:2626
LEX_CSTRING auth
Definition: table.h:2625
bool uses_identified_with_clause
Definition: table.h:2638
bool uses_authentication_string_clause
Definition: table.h:2637
bool finish_registration
Definition: table.h:2658
LEX_CSTRING plugin
Definition: table.h:2624
LEX_CSTRING client_plugin
Definition: table.h:2628
void copy(LEX_MFA *m, MEM_ROOT *alloc)
Definition: table.cc:7408
bool uses_identified_by_clause
Definition: table.h:2636
bool drop_factor
Definition: table.h:2647
bool init_registration
Definition: table.h:2656
uint nth_factor
Definition: table.h:2629
bool requires_registration
Definition: table.h:2652
LEX_CSTRING challenge_response
Definition: table.h:2627
bool add_factor
Definition: table.h:2643
bool has_password_generator
Definition: table.h:2639
LEX_MFA()
Definition: table.h:2660
bool unregister
Definition: table.h:2654
void reset()
Definition: table.h:2661
bool passwordless
Definition: table.h:2641
Definition: table.h:2732
bool retain_current_password
Definition: table.h:2737
LEX_ALTER alter_status
Definition: table.h:2739
List< LEX_MFA > mfa_list
Definition: table.h:2742
bool uses_replace_clause
Definition: table.h:2736
LEX_CSTRING host
Definition: table.h:2734
static LEX_USER * alloc(THD *thd)
Definition: table.cc:7444
void init()
Definition: table.h:2745
LEX_CSTRING current_auth
Definition: table.h:2735
bool with_initial_auth
Definition: table.h:2743
LEX_CSTRING user
Definition: table.h:2733
LEX_MFA first_factor_auth_info
Definition: table.h:2741
LEX_USER()
Definition: table.h:2772
bool discard_old_password
Definition: table.h:2738
bool add_mfa_identifications(LEX_MFA *factor2, LEX_MFA *factor3=nullptr)
Definition: table.cc:7451
The LEX object currently serves three different purposes:
Definition: sql_lex.h:3838
Definition: thr_lock.h:99
thr_lock_type type
Definition: thr_lock.h:100
@ TABLE
Definition: mdl.h:405
The MEM_ROOT is a simple arena, where allocations are carved out of larger blocks.
Definition: my_alloc.h:83
void ClearForReuse()
Similar to Clear(), but anticipates that the block will be reused for further allocations.
Definition: my_alloc.cc:190
Definition: mysql_lex_string.h:40
const char * str
Definition: mysql_lex_string.h:41
size_t length
Definition: mysql_lex_string.h:42
Definition: mysql_lex_string.h:35
Definition: my_bitmap.h:43
my_bitmap_map * bitmap
Definition: my_bitmap.h:44
Struct NESTED_JOIN is used to represent how tables are connected through outer join operations and se...
Definition: nested_join.h:78
Definition: item.h:402
Definition: table.h:4173
uint32 locked
Definition: table.h:4176
char * table
Definition: table.h:4175
OPEN_TABLE_LIST * next
Definition: table.h:4174
uint32 in_use
Definition: table.h:4176
char * db
Definition: table.h:4175
Definition: table.h:287
const char * used_alias
Tells whether this ORDER element was referenced with an alias or with an expression in the query,...
Definition: table.h:325
char * buff
Definition: table.h:336
bool is_item_original() const
Definition: table.h:289
Item_rollup_group_item * rollup_item
Definition: table.h:314
bool in_field_list
Definition: table.h:318
Item * item_initial
The initial ordering expression.
Definition: table.h:304
ORDER * next
Definition: table.h:291
MY_BITMAP * grouping_set_info
If the query block includes non-primitive grouping, then these modifiers are represented as grouping ...
Definition: table.h:299
enum_order direction
Definition: table.h:316
Item ** item
Points at the item in the select fields.
Definition: table.h:312
table_map depend_map
Definition: table.h:337
Field * field_in_tmp_table
When GROUP BY is implemented with a temporary table (i.e.
Definition: table.h:335
table_map used
Definition: table.h:337
bool is_explicit
Definition: table.h:338
A struct that contains execution time state used for partial update of JSON columns.
Definition: table.cc:7499
Definition: table.h:2498
int value
Definition: table.h:2516
const char * field_name
This is used as column name.
Definition: table.h:2502
enum_field_types field_type
This denotes data type for the column.
Definition: table.h:2515
const char * old_name
Definition: table.h:2526
uint open_method
Definition: table.h:2527
uint field_flags
This is used to set column attributes.
Definition: table.h:2525
uint field_length
For string-type columns, this is the maximum number of characters.
Definition: table.h:2509
Definition: table.h:2530
int(* process_table)(THD *thd, Table_ref *tables, TABLE *table, bool res, LEX_CSTRING db_name, LEX_CSTRING table_name)
Definition: table.h:2537
int(* fill_table)(THD *thd, Table_ref *tables, Item *cond)
Definition: table.h:2534
ST_FIELD_INFO * fields_info
Definition: table.h:2532
int(* old_format)(THD *thd, ST_SCHEMA_TABLE *schema_table)
Definition: table.h:2536
bool hidden
Definition: table.h:2539
const char * table_name
Definition: table.h:2531
Definition: table.h:602
const TABLE_FIELD_TYPE * field
Definition: table.h:604
uint count
Definition: table.h:603
Definition: table.h:596
LEX_CSTRING cset
Definition: table.h:599
LEX_CSTRING name
Definition: table.h:597
LEX_CSTRING type
Definition: table.h:598
This structure is shared between different table objects.
Definition: table.h:702
ulong stored_rec_length
Definition: table.h:803
uint next_number_index
Definition: table.h:920
Key_map keys_in_use
The set of indexes that are not disabled for this table.
Definition: table.h:794
TABLE_SHARE_FOREIGN_KEY_PARENT_INFO * foreign_key_parent
Definition: table.h:1039
bool visit_subgraph(Wait_for_flush *waiting_ticket, MDL_wait_for_graph_visitor *gvisitor)
Traverse portion of wait-for graph which is reachable through this table share in search for deadlock...
Definition: table.cc:3923
Table_cache_element ** cache_element
Array of table_cache_instances pointers to elements of table caches respresenting this table in each ...
Definition: table.h:747
MEM_ROOT mem_root
Definition: table.h:728
bool is_primary_engine() const
Does this TABLE_SHARE represent a table in a primary storage engine?
Definition: table.h:1246
void destroy()
Release resources and free memory occupied by the table share.
Definition: table.cc:542
TABLE_SHARE_FOREIGN_KEY_INFO * foreign_key
Definition: table.h:1037
bool is_secondary_engine() const
Does this TABLE_SHARE represent a table in a secondary storage engine?
Definition: table.h:1249
uint stats_sample_pages
Definition: table.h:840
handlerton * db_type() const
Definition: table.h:808
Table_histograms_collection * m_histograms
Definition: table.h:723
LEX_STRING comment
Definition: table.h:756
Handler_share * ha_share
Main handler's share.
Definition: table.h:1002
MEM_ROOT * alloc_for_tmp_file_handler
Used to allocate new handler for internal temporary table when the size limitation of the primary sto...
Definition: table.h:733
enum_stats_auto_recalc stats_auto_recalc
Definition: table.h:843
const char * tablespace
Definition: table.h:952
partition_info * m_part_info
Partition meta data.
Definition: table.h:972
LEX_STRING compress
Definition: table.h:757
const TABLE_FIELD_DEF * table_field_def_cache
Cache the checked structure of this table.
Definition: table.h:999
uint column_bitmap_size
Definition: table.h:924
ulong mysql_version
Definition: table.h:801
uint max_tmp_key_parts
For materialized derived tables: allocated size of base_key_parts array of all TABLE objects.
Definition: table.h:881
uint total_key_length
Definition: table.h:855
TYPELIB keynames
Definition: table.h:735
uchar * default_values
Definition: table.h:755
LEX_STRING encrypt_type
Definition: table.h:758
PSI_table_share * m_psi
Instrumentation for this table share.
Definition: table.h:1005
bool is_missing_primary_key() const
Determine if the table is missing a PRIMARY KEY.
Definition: table.h:1193
bool db_low_byte_first
Definition: table.h:930
Schema_read_only
Schema's read only mode - ON (true) or OFF (false).
Definition: table.h:1052
LEX_CSTRING table_cache_key
Definition: table.h:779
unsigned int m_ref_count
How many TABLE objects use this TABLE_SHARE.
Definition: table.h:1264
unsigned long version() const
Returns the version of this TABLE_SHARE.
Definition: table.h:1103
uint max_unique_length
Definition: table.h:854
tmp_table_type tmp_table
Definition: table.h:822
unsigned long m_version
TABLE_SHARE version, if changed the TABLE_SHARE must be reopened.
Definition: table.h:1271
uint find_first_unused_tmp_key(const Key_map &k)
For a materialized derived table: informs the share that certain not-yet-used keys are going to be us...
Definition: table.cc:6049
int cached_row_logging_check
Definition: table.h:942
ulong reclength
Definition: table.h:802
uint varchar_fields
Definition: table.h:867
uint next_number_keypart
Definition: table.h:922
bool secondary_load
Secondary engine load status.
Definition: table.h:763
uint tmp_handler_count
Only for internal temporary tables.
Definition: table.h:829
Field ** field
Definition: table.h:750
ulong avg_row_length
Definition: table.h:800
plugin_ref db_plugin
Definition: table.h:807
LEX_CSTRING table_name
Definition: table.h:781
const dd::View * view_object
View object holding view definition read from DD.
Definition: table.h:1017
uint db_create_options
Bitmap with flags representing some of table options/attributes.
Definition: table.h:907
uint rec_buff_length
Definition: table.h:848
uint blob_fields
Definition: table.h:866
uint max_tmp_keys
For materialized derived tables: allocated size of key_info array.
Definition: table.h:876
LEX_STRING connect_string
Definition: table.h:784
Field ** found_next_number_field
Definition: table.h:751
ha_rows min_rows
Definition: table.h:799
bool is_referenced_by_foreign_key() const
Returns whether this table is referenced by a foreign key.
Definition: table.h:1260
uint foreign_keys
Arrays with descriptions of foreign keys in which this table participates as child or parent.
Definition: table.h:1036
Schema_read_only schema_read_only
Definition: table.h:1053
bool wait_for_old_version(THD *thd, struct timespec *abstime, uint deadlock_weight)
Wait until the subject share is removed from the table definition cache and make sure it's destroyed.
Definition: table.cc:4017
uint fields
Definition: table.h:847
uint tmp_open_count
Only for internal temporary tables.
Definition: table.h:835
Key_name * key_names
Array of names for generated keys, used for materialized derived tables.
Definition: table.h:886
Key_map keys_for_keyread
Definition: table.h:798
char * partition_info_str
Storing the full partitioning clause (PARTITION BY ...) which is used when creating new partition_inf...
Definition: table.h:986
TABLE_SHARE(unsigned long version, bool secondary)
Create a new TABLE_SHARE with the given version number.
Definition: table.h:711
uint null_bytes
Definition: table.h:846
bool system
Definition: table.h:929
bool is_view
Definition: table.h:932
ulonglong get_table_ref_version() const
Return a table metadata version.
Definition: table.cc:4090
uint rowid_field_offset
Definition: table.h:917
uint max_key_length
Definition: table.h:853
ulong * base_rec_per_key
Records per key array, used for materialized derived tables.
Definition: table.h:892
bool has_secondary_engine() const
Does this TABLE_SHARE represent a primary table that has a shadow copy in a secondary storage engine?
Definition: table.h:1255
bool is_distinct
Whether this is a temporary table that already has a UNIQUE index (removing duplicate rows on insert)...
Definition: table.h:863
dd::Table * tmp_table_def
Data-dictionary object describing explicit temporary table represented by this share.
Definition: table.h:1025
TABLE_SHARE * next
Definition: table.h:738
LEX_STRING path
Definition: table.h:782
bool m_open_in_progress
Definition: table.h:933
uint next_number_key_offset
Definition: table.h:921
uint keys
Definition: table.h:849
Key_map visible_indexes
The set of visible and enabled indexes for this table.
Definition: table.h:797
uint foreign_key_parents
Definition: table.h:1038
bool has_old_version() const
Is this table share being expelled from the table definition cache?
Definition: table.h:1113
mysql_mutex_t LOCK_ha_data
Definition: table.h:737
Wait_for_flush_list m_flush_tickets
List of tickets representing threads waiting for the share to be flushed.
Definition: table.h:1010
void clear_version()
Set the version of this TABLE_SHARE to zero.
Definition: table.cc:531
uint gen_def_field_count
Number of fields having the default value generated.
Definition: table.h:928
MY_BITMAP all_set
Definition: table.h:768
unsigned int ref_count() const
How many TABLE objects use this TABLE_SHARE.
Definition: table.h:1219
uint last_null_bit_pos
Definition: table.h:846
TABLE_CATEGORY table_category
Category of this table.
Definition: table.h:726
bool error
Definition: table.h:923
unsigned int decrement_ref_count()
Decrement the reference count by one.
Definition: table.h:1238
const CHARSET_INFO * table_charset
Definition: table.h:765
unsigned int increment_ref_count()
Increment the reference count by one.
Definition: table.h:1228
mysql::binlog::event::Table_id table_map_id
Definition: table.h:934
bool auto_partitioned
Filled in when reading from frm.
Definition: table.h:979
void set_table_cache_key(char *key_buff, const char *key, size_t key_length)
Set share's table cache key and update its db and table name appropriately.
Definition: table.h:1095
void set_table_cache_key(char *key_buff, size_t key_length)
Set share's table cache key and update its db and table name appropriately.
Definition: table.h:1069
ulonglong autoextend_size
Definition: table.h:805
uint primary_key
Definition: table.h:919
ha_storage_media default_storage_media
Definition: table.h:949
rec_per_key_t * base_rec_per_key_float
Records per key array, float rep., used for materialized derived tables.
Definition: table.h:898
bool m_secondary_engine
Does this TABLE_SHARE represent a table in a secondary storage engine?
Definition: table.h:1275
std::uint32_t key_block_size
Definition: table.h:839
bool crashed
Definition: table.h:931
Key_map usable_indexes(const THD *thd) const
The set of indexes that the optimizer may use when creating an execution plan.
Definition: table.cc:505
LEX_CSTRING normalized_path
Definition: table.h:783
uint key_parts
Definition: table.h:850
uint vfields
Number of generated fields.
Definition: table.h:926
enum enum_table_ref_type get_table_ref_type() const
Convert unrelated members of TABLE_SHARE to one enum representing its type.
Definition: table.h:1121
uint db_options_in_use
Bitmap with flags representing some of table options/attributes which are in use by storage engine.
Definition: table.h:916
ha_rows max_rows
Definition: table.h:799
ulonglong get_table_def_version() const
Definition: table.h:1100
TYPELIB * intervals
Definition: table.h:736
uint first_unused_tmp_key
For materialized derived tables;.
Definition: table.h:872
TABLE_SHARE ** prev
Definition: table.h:738
uint null_fields
Definition: table.h:865
LEX_CSTRING secondary_engine
Secondary storage engine.
Definition: table.h:761
KEY * key_info
Definition: table.h:752
uint partition_info_str_len
Definition: table.h:987
LEX_CSTRING db
Definition: table.h:780
LEX_CSTRING engine_attribute
Definition: table.h:786
LEX_CSTRING secondary_engine_attribute
Definition: table.h:787
uint * blob_field
Definition: table.h:753
enum row_type real_row_type
Real row format used for the table by the storage engine.
Definition: table.h:821
TABLE_SHARE()=default
Sql_check_constraint_share_list * check_constraint_share_list
Definition: table.h:1042
Query_block * owner_of_possible_tmp_keys
For materialized derived tables;.
Definition: table.h:1028
Definition: table.h:1407
void mark_columns_used_by_index(uint index)
Definition: table.cc:5503
bool materialized
For a materializable derived or SJ table: true if has been materialized.
Definition: table.h:1885
void mark_generated_columns(bool is_update)
Update the write/read_set for generated columns when doing update and insert operation.
Definition: table.cc:6235
class QEP_TAB * qep_tab
Definition: table.h:1889
bool m_invalid_dict
This TABLE object is invalid and cannot be reused.
Definition: table.h:1865
query_id_t query_id
Definition: table.h:1737
bool force_index_order
Flag set when the statement contains FORCE INDEX FOR ORDER BY See Table_ref::process_index_hints().
Definition: table.h:1799
void column_bitmaps_set_no_signal(MY_BITMAP *read_set_arg, MY_BITMAP *write_set_arg)
Definition: table.h:1963
void mark_columns_needed_for_update(THD *thd, bool mark_binlog_columns)
Mark columns needed for doing an update of a row.
Definition: table.cc:5671
const char * alias
alias or table name
Definition: table.h:1638
partition_info * part_info
Definition: table.h:1924
uint8 m_status
Definition: table.h:1777
bool key_read
If set, the optimizer has found that row retrieval should access index tree only.
Definition: table.h:1814
bool no_replicate
If set, indicate that the table is not replicated by the server.
Definition: table.h:1823
class JOIN_TAB * join_tab
Definition: table.h:1888
void set_no_row()
Set status for row buffer: contains no row.
Definition: table.h:2096
void mark_columns_needed_for_insert(THD *thd)
Definition: table.cc:6179
Field ** vfield
Pointer to generated columns.
Definition: table.h:1510
void clear_column_bitmaps(void)
Definition: table.cc:5403
uint tmp_table_seq_id
Internal tmp table sequential number.
Definition: table.h:1938
TABLE ** cache_prev
Definition: table.h:1420
Key_map covering_keys
Definition: table.h:1466
uchar * null_flags
Pointer to the null flags of record[0].
Definition: table.h:1639
Key_map keys_in_use_for_group_by
Definition: table.h:1497
Key_map keys_in_use_for_query
Definition: table.h:1495
Field_longlong * set_counter()
Definition: table.h:1625
void set_storage_handler(handler *file_arg)
Set storage handler for temporary table.
Definition: table.h:2026
bool has_null_row() const
Definition: table.h:2149
Record_buffer m_record_buffer
Buffer for use in multi-row reads. Initially empty.
Definition: table.h:1460
void set_deleted()
Set the contents of table to be "deleted", ie "not created", after having deleted the contents.
Definition: table.h:2046
Set_operator_type m_set_op_type
Holds the set operation type.
Definition: table.h:1574
void set_created()
Set the table as "created", and enable flags in storage engine that could not be enabled without an i...
Definition: table.cc:6166
void use_all_columns()
Definition: table.h:1968
bool has_updated_row() const
Definition: table.h:2152
TABLE * cache_next
Links for the lists of used/unused TABLE objects for the particular table in the specific instance of...
Definition: table.h:1420
Set_operator_type set_op_type()
Returns the set operation type.
Definition: table.h:1589
void blobs_need_not_keep_old_value()
Virtual fields of type BLOB have a flag m_keep_old_value.
Definition: table.cc:8027
Table_ref * pos_in_table_list
Definition: table.h:1634
void set_set_op(Field_longlong *set_counter, bool except, bool distinct)
Initialize the set counter field pointer and the type of set operation other than UNION*.
Definition: table.h:1616
ORDER * group
Definition: table.h:1637
bool has_binary_diff_columns() const
Does this table have any columns that can be updated using partial update in the current row?
Definition: table.cc:7620
void set_use_hash_map(bool use_hash_map)
Definition: table.h:1582
void mark_columns_per_binlog_row_image(THD *thd)
Definition: table.cc:5743
ha_rows quick_condition_rows
Definition: table.h:1759
THD * in_use
The current session using this table object.
Definition: table.h:1449
void disable_logical_diffs_for_current_row(const Field *field) const
Temporarily disable collection of Json_diff objects describing the logical changes of a JSON column i...
Definition: table.cc:7855
MY_BITMAP * fields_set_during_insert
A pointer to the bitmap of table fields (columns), which are explicitly set in the INSERT INTO statem...
Definition: table.h:1717
void mark_columns_needed_for_delete(THD *thd)
Definition: table.cc:5594
ha_rows quick_rows[MAX_KEY]
Definition: table.h:1743
thr_lock_type lock_type
Definition: table.h:1890
bool null_row
Definition: table.h:1784
uint lock_data_start
Definition: table.h:1762
bool const_table
Definition: table.h:1806
MY_BITMAP read_set_internal
A bitmap of fields that are explicitly referenced by the query.
Definition: table.h:1704
bool is_marked_for_partial_update(const Field *field) const
Has this column been marked for partial update?
Definition: table.cc:7614
bool force_index_group
Flag set when the statement contains FORCE INDEX FOR GROUP BY See Table_ref::process_index_hints().
Definition: table.h:1805
bool has_storage_handler() const
Definition: table.h:2023
bool open_by_handler
Definition: table.h:1825
void bind_value_generators_to_fields()
Bind all the table's value generator columns in all the forms: stored/virtual GC, default expressions...
Definition: table.cc:4282
Table_ref * pos_in_locked_tables
Definition: table.h:1636
void disable_binary_diffs_for_current_row(const Field *field)
Temporarily disable collection of binary diffs for a column in the current row.
Definition: table.cc:7602
void set_keyread(bool flag)
Definition: table.cc:6155
bool index_contains_some_virtual_gcol(uint index_no) const
Check whether the given index has a virtual generated columns.
Definition: table.h:2010
uint db_stat
Definition: table.h:1764
bool is_logical_diff_enabled(const Field *field) const
Is partial update using logical diffs enabled on this JSON column?
Definition: table.cc:7833
bool has_invalid_dict() const
Definition: table.h:1981
bool has_invalid_stats()
Definition: table.h:1986
uchar * insert_values
Definition: table.h:1457
ptrdiff_t default_values_offset() const
Definition: table.h:2018
uchar * record[2]
Definition: table.h:1454
void invalidate_dict()
Definition: table.cc:8074
void mark_auto_increment_column(void)
Mark auto-increment fields as used fields in both read and write maps.
Definition: table.cc:5563
bool alias_name_used
Definition: table.h:1843
bool fill_item_list(mem_root_deque< Item * > *item_list) const
Create Item_field for each column in the table.
Definition: table.cc:4339
bool impossible_range
Definition: table.h:1896
bool is_binary_diff_enabled(const Field *field) const
Is partial update using binary diffs enabled on this JSON column?
Definition: table.cc:7827
void invalidate_stats()
Definition: table.cc:8085
Cost_model_table m_cost_model
Cost model object for operations on this table.
Definition: table.h:1931
bool should_binlog_drop_if_temp_flag
This flag decides whether or not we should log the drop temporary table command.
Definition: table.h:2258
void cleanup_value_generator_items()
Clean any state in items associated with generated columns to be ready for the next statement.
Definition: table.cc:4308
bool m_deduplicate_with_hash_map
If false, any de-duplication happens via an index on this table (e.g.
Definition: table.h:1559
Field_longlong * m_set_counter
The set counter.
Definition: table.h:1546
void init_cost_model(const Cost_model_server *cost_model_server)
Initialize the optimizer cost model.
Definition: table.h:2183
bool not_exists_optimize
Definition: table.h:1891
bool force_index
Definition: table.h:1793
void init(THD *thd, Table_ref *tl)
Initialize TABLE instance (newly created, or coming either from table cache or THD::temporary_tables ...
Definition: table.cc:4117
bool is_except() const
Definition: table.h:1602
MY_BITMAP * read_set
The read set contains the set of columns that the execution engine needs to process the query.
Definition: table.h:1686
bool should_binlog_drop_if_temp(void) const
Definition: table.cc:8042
bool get_fields_in_item_tree
Definition: table.h:1844
uint visible_field_count() const
Definition: table.h:1993
const Binary_diff_vector * get_binary_diffs(const Field *field) const
Get the list of binary diffs that have been collected for a given column in the current row,...
Definition: table.cc:7711
void mark_check_constraint_columns(bool is_update)
Update the read_map with columns needed for check constraint evaluation when doing update and insert ...
Definition: table.cc:6295
int current_lock
Definition: table.h:1765
void move_tmp_key(int old_idx, bool modify_share)
For a materialized derived table: moves a KEY definition from a position to the first not-yet-used po...
Definition: table.cc:6072
uint quick_n_ranges[MAX_KEY]
Definition: table.h:1749
TABLE * next
Definition: table.h:1410
bool add_binary_diff(const Field *field, size_t offset, size_t length)
Add a binary diff for a column that is updated using partial update.
Definition: table.cc:7716
bool m_invalid_stats
This TABLE object is invalid and cannot be reused as it has outdated rec_per_key and handler stats.
Definition: table.h:1874
bool empty_result_table()
Empties internal temporary table (deletes rows, closes scan)
Definition: table.cc:8046
void cleanup_partial_update()
Clean up state used for partial update of JSON columns.
Definition: table.cc:7681
uint lock_position
Definition: table.h:1761
Key_map quick_keys
Definition: table.h:1467
void restore_null_flags()
Restore the NULL flags of the current row from the designated buffer.
Definition: table.h:2169
Table_trigger_dispatcher * triggers
Definition: table.h:1633
bool no_keyread
Certain statements which need the full row, set this to ban index-only access.
Definition: table.h:1819
bool is_intersect() const
Definition: table.h:1597
void set_tmp_table_seq_id(uint arg)
Definition: table.h:2212
Partial_update_info * m_partial_update_info
Object which contains execution time state used for partial update of JSON columns.
Definition: table.h:2252
void set_binlog_drop_if_temp(bool should_binlog)
Set the variable should_binlog_drop_if_temp_flag, so that the logging of temporary tables can be deci...
Definition: table.cc:8038
void mark_gcol_in_maps(const Field *field)
Adds a generated column and its dependencies to the read_set/write_set bitmaps.
Definition: table.cc:7280
void set_deleted_row()
Set "deleted" property for the current row.
Definition: table.h:2140
void reset_null_row()
Clear "null row" status for the current row.
Definition: table.h:2128
Field ** gen_def_fields_ptr
Pointer to fields having the default value generated.
Definition: table.h:1512
MY_BITMAP fields_for_functional_indexes
A bitmap marking the hidden generated columns that exists for functional indexes.
Definition: table.h:1437
struct TABLE::@189 reginfo
void set_not_started()
Life cycle of the row buffer is as follows:
Definition: table.h:2076
const histograms::Histogram * find_histogram(uint field_index) const
Find the histogram for the given field index.
Definition: table.cc:7867
SortingIterator * sorting_iterator
Not owned by the TABLE; used only from filesort_free_buffers().
Definition: table.h:1916
bool m_last_operation_is_distinct
If m_set_counter is set: true if last block has DISTINCT semantics, either because it is marked as su...
Definition: table.h:1553
key_part_map const_key_parts[MAX_KEY]
Definition: table.h:1746
Field ** field
Definition: table.h:1450
bool alloc_tmp_keys(uint new_key_count, uint new_key_part_count, bool modify_share)
Allocate space for keys, for a materialized derived table.
Definition: table.cc:5825
MEM_ROOT mem_root
Definition: table.h:1904
void column_bitmaps_set(MY_BITMAP *read_set_arg, MY_BITMAP *write_set_arg)
Definition: table.cc:7310
bool uses_hash_map() const
Definition: table.h:1586
uint hidden_field_count
Count of hidden fields, if internal temporary table; 0 otherwise.
Definition: table.h:1452
bool is_nullable() const
Return whether table is nullable.
Definition: table.h:2051
MY_BITMAP tmp_set
Definition: table.h:1644
MDL_ticket * mdl_ticket
Definition: table.h:1927
bool has_gcol() const
Definition: table.h:2054
bool all_partitions_pruned_away
Definition: table.h:1926
MY_BITMAP def_read_set
Definition: table.h:1644
String * get_partial_update_buffer()
Get a buffer that can be used to hold the partially updated column value while performing partial upd...
Definition: table.cc:7687
bool setup_partial_update()
Definition: table.cc:7652
bool has_deleted_row() const
Definition: table.h:2155
bool check_read_removal(uint index)
Read removal is possible if the selected quick read method is using full unique index.
Definition: table.cc:7072
const Json_diff_vector * get_logical_diffs(const Field_json *field) const
Get the list of JSON diffs that have been collected for a given column in the current row,...
Definition: table.cc:7821
KEY_PART_INFO * base_key_parts
Key part array for generated keys, used for materialized derived tables.
Definition: table.h:1505
bool is_started() const
Definition: table.h:2082
Set_operator_type
Definition: table.h:1562
@ SOT_EXCEPT_DISTINCT
Definition: table.h:1569
@ SOT_NONE
Definition: table.h:1563
@ SOT_UNION_ALL
Definition: table.h:1564
@ SOT_INTERSECT_ALL
Definition: table.h:1566
@ SOT_INTERSECT_DISTINCT
Definition: table.h:1567
@ SOT_UNION_DISTINCT
Definition: table.h:1565
@ SOT_EXCEPT_ALL
Definition: table.h:1568
MY_BITMAP cond_set
Definition: table.h:1653
void mark_columns_used_by_index_no_reset(uint index, MY_BITMAP *map, uint key_parts=0) const
mark columns used by key, but don't reset other fields
Definition: table.cc:5541
void reset()
Reset state of fields after optimization and execution.
Definition: table.cc:4187
MY_BITMAP pack_row_tmp_set
Definition: table.h:1644
void default_column_bitmaps()
Definition: table.h:1971
void drop_unused_tmp_keys(bool modify_share)
For a materialized derived table: after move_tmp_key() has moved all definitions of used KEYs,...
Definition: table.cc:6129
void clear_partial_update_diffs()
Clear the diffs that have been collected for partial update of JSON columns, and re-enable partial up...
Definition: table.cc:7692
void set_null_row()
Set current row as "null row", for use in null-complemented outer join.
Definition: table.h:2121
handler * get_primary_handler() const
Returns the primary engine handler for the table.
Definition: table.cc:7317
Sql_table_check_constraint_list * table_check_constraint_list
Definition: table.h:1768
Key_map possible_quick_keys
Definition: table.h:1482
bool created
For tmp tables.
Definition: table.h:1881
bool has_row() const
Definition: table.h:2146
const Cost_model_table * cost_model() const
Return the cost model object for this table.
Definition: table.h:2190
Field * next_number_field
Definition: table.h:1507
void update_const_key_parts(Item *conds)
Update TABLE::const_key_parts for single table UPDATE/DELETE query.
Definition: table.cc:7042
void save_null_flags()
Save the NULL flags of the current row into the designated buffer.
Definition: table.h:2164
Field * found_next_number_field
Definition: table.h:1508
Key_map keys_in_use_for_order_by
Definition: table.h:1499
void set_row_status_from_handler(int status)
Set "row found" status from handler result.
Definition: table.h:2106
Field ** visible_field_ptr() const
Definition: table.h:1991
uchar * null_flags_saved
Saved null_flags while null_row is true.
Definition: table.h:1640
uchar * write_row_record
Definition: table.h:1455
ha_rows m_limit_rows
A priori unlimited.
Definition: table.h:1538
MY_BITMAP def_write_set
Definition: table.h:1644
bool is_union_or_table() const
Test if this tmp table stores the result of a UNION set operation or a single table.
Definition: table.h:1580
uint lock_count
Definition: table.h:1763
Field * hash_field
Field used by unique constraint.
Definition: table.h:1514
MY_BITMAP def_fields_set_during_insert
Bitmap of table fields (columns), which are explicitly set in the INSERT INTO statement.
Definition: table.h:1662
bool mark_column_for_partial_update(const Field *field)
Mark a given column as one that can potentially be updated using partial update during execution of a...
Definition: table.cc:7587
Field * fts_doc_id_field
Definition: table.h:1630
bool autoinc_field_has_explicit_non_null_value
To indicate that value of the auto_increment field was provided explicitly by the user or from some o...
Definition: table.h:1842
KEY * key_info
Definition: table.h:1500
bool init_tmp_table(THD *thd, TABLE_SHARE *share, MEM_ROOT *m_root, CHARSET_INFO *charset, const char *alias, Field **fld, uint *blob_fld, bool is_virtual)
Initialize table as internal tmp table.
Definition: table.cc:4232
void set_found_row()
Set status for row buffer: contains row.
Definition: table.h:2085
void mark_column_used(Field *field, enum enum_mark_columns mark)
Mark column as either read or written (or none) according to mark_used.
Definition: table.cc:5460
void set_nullable()
Set table as nullable, ie it is inner wrt some outer join.
Definition: table.h:2048
Blob_mem_storage * blob_storage
Initialized in Item_func_group_concat::setup for appropriate temporary table if GROUP_CONCAT is used ...
Definition: table.h:1910
void set_updated_row()
Set "updated" property for the current row.
Definition: table.h:2134
TABLE * prev
Definition: table.h:1410
void prepare_for_position(void)
Tell handler we are going to call position() and rnd_pos() later.
Definition: table.cc:5435
TABLE_SHARE * s
Definition: table.h:1408
bool has_columns_marked_for_partial_update() const
Does this table have any columns that were marked with mark_column_for_partial_update()?
Definition: table.cc:7672
MY_BITMAP * m_partial_update_columns
Bitmap that tells which columns are eligible for partial update in an update statement.
Definition: table.h:2243
bool copy_blobs
Definition: table.h:1786
void add_logical_diff(const Field_json *field, const Json_seekable_path &path, enum_json_diff_operation operation, const Json_wrapper *new_value)
Add a logical JSON diff describing a logical change to a JSON column in partial update.
Definition: table.cc:7791
bool is_distinct() const
Definition: table.h:1607
bool add_tmp_key(Field_map *key_parts, bool invisible, bool modify_share)
Add one key to a materialized derived table.
Definition: table.cc:5940
SortingIterator * duplicate_removal_iterator
Definition: table.h:1917
void update_covering_prefix_keys(Field *field, uint16 key_read_length, Key_map *covering_prefix_keys)
Update covering keys depending on max read key length.
Definition: table.cc:8058
bool nullable
If true, this table is inner w.r.t.
Definition: table.h:1775
Key_map merge_keys
Definition: table.h:1470
Sort_result unique_result
The result of applying a unique operation (by row ID) to the table, if done.
Definition: table.h:1923
bool is_created() const
Return true if table is instantiated, and false otherwise.
Definition: table.h:2035
uint quick_key_parts[MAX_KEY]
Definition: table.h:1748
MY_BITMAP * write_set
Definition: table.h:1688
bool no_rows
True if writes to this table should not write rows and just write keys.
Definition: table.h:1808
Definition: typelib.h:35
Definition: table.h:668
LEX_CSTRING referenced_table_db
Definition: table.h:669
dd::Foreign_key::enum_rule delete_rule
Definition: table.h:676
LEX_CSTRING unique_constraint_name
Name of unique key matching FK in parent table, "" if there is no unique key.
Definition: table.h:675
LEX_CSTRING * column_name
Arrays with names of referencing columns of the FK.
Definition: table.h:681
uint columns
Definition: table.h:677
dd::Foreign_key::enum_rule update_rule
Definition: table.h:676
LEX_CSTRING referenced_table_name
Definition: table.h:670
dd::Foreign_key::enum_rule delete_rule
Definition: table.h:687
dd::Foreign_key::enum_rule update_rule
Definition: table.h:687
LEX_CSTRING referencing_table_name
Definition: table.h:686
LEX_CSTRING referencing_table_db
Definition: table.h:685
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
Definition: sql_plugin_ref.h:45
Contains the class Table_id, mainly used for row based replication.
tablesample_type
Definition: tablesample.h:27
thr_lock_type
Definition: thr_lock.h:51
@ TL_WRITE_LOW_PRIORITY
Definition: thr_lock.h:90
@ TL_UNLOCK
Definition: thr_lock.h:53
@ TL_READ
Definition: thr_lock.h:62
@ TL_WRITE_ALLOW_WRITE
Definition: thr_lock.h:73
static void mark()
Definition: xcom_transport.cc:693