MySQL 9.3.0
Source Code Documentation
dict0mem.h
Go to the documentation of this file.
1/*****************************************************************************
2
3Copyright (c) 1996, 2025, Oracle and/or its affiliates.
4Copyright (c) 2012, Facebook Inc.
5
6This program is free software; you can redistribute it and/or modify it under
7the terms of the GNU General Public License, version 2.0, as published by the
8Free Software Foundation.
9
10This program is designed to work with certain software (including
11but not limited to OpenSSL) that is licensed under separate terms,
12as designated in a particular file or component or in included license
13documentation. The authors of MySQL hereby grant you an additional
14permission to link the program and your derivative works with the
15separately licensed software that they have either included with
16the program or referenced in the documentation.
17
18This program is distributed in the hope that it will be useful, but WITHOUT
19ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
20FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
21for more details.
22
23You should have received a copy of the GNU General Public License along with
24this program; if not, write to the Free Software Foundation, Inc.,
2551 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26
27*****************************************************************************/
28
29/** @file include/dict0mem.h
30 Data dictionary memory object creation
31
32 Created 1/8/1996 Heikki Tuuri
33 *******************************************************/
34
35#ifndef dict0mem_h
36#define dict0mem_h
37
38#include "sql/dd/object_id.h"
39#include "sql/dd/types/column.h"
40#include "univ.i"
41#if defined UNIV_COMPILE_TEST_FUNCS || defined UNIV_HOTBACKUP
43#endif /* UNIV_COMPILE_TEST_FUNCS || UNIV_HOTBACKUP */
44#include "btr0types.h"
45#include "data0type.h"
46#include "dict0types.h"
47#include "mem0mem.h"
48#include "rem0types.h"
49#include "row0types.h"
50#ifndef UNIV_HOTBACKUP
51#include "lock0types.h"
52#include "que0types.h"
53#endif /* !UNIV_HOTBACKUP */
54#include "hash0hash.h"
55#include "sync0rw.h"
56#include "trx0types.h"
57#include "ut0byte.h"
58#include "ut0mem.h"
59#include "ut0rnd.h"
60#ifndef UNIV_HOTBACKUP
61#include "fts0fts.h"
62#endif /* !UNIV_HOTBACKUP */
63#include "buf0buf.h"
64#include "gis0type.h"
65#ifndef UNIV_HOTBACKUP
66#include "os0once.h"
67#endif /* !UNIV_HOTBACKUP */
68#include "dict/mem.h"
69#include "ut0new.h"
70
71#include "sql/sql_const.h" /* MAX_KEY_LENGTH */
72#include "sql/table.h"
73
74#include <algorithm>
75#include <iterator>
76#include <memory> /* std::unique_ptr */
77#include <set>
78#include <string>
79#include <vector>
80
81/* Forward declaration. */
82struct ib_rbt_t;
83
84/** Format of INSTANTLY DROPPED column names. */
85constexpr char INSTANT_DROP_SUFFIX_8_0_29[] = "_dropped_v";
86constexpr char INSTANT_DROP_PREFIX_8_0_32[] = "!hidden!_dropped_";
87
88/** index/table name used while applying REDO logs during recovery */
89constexpr char RECOVERY_INDEX_TABLE_NAME[] = "LOG_DUMMY";
90
91/** Type flags of an index: OR'ing of the flags is allowed to define a
92combination of types */
93/** @{ */
94/** clustered index; for other than auto-generated clustered indexes, also
95 DICT_UNIQUE will be set */
96constexpr uint32_t DICT_CLUSTERED = 1;
97/** unique index */
98constexpr uint32_t DICT_UNIQUE = 2;
99/** insert buffer tree */
100constexpr uint32_t DICT_IBUF = 8;
101/** bit to store the corrupted flag in SYS_INDEXES.TYPE */
102constexpr uint32_t DICT_CORRUPT = 16;
103/** FTS index; can't be combined with the other flags */
104constexpr uint32_t DICT_FTS = 32;
105/** SPATIAL index; can't be combined with the other flags */
106constexpr uint32_t DICT_SPATIAL = 64;
107/** Index on Virtual column */
108constexpr uint32_t DICT_VIRTUAL = 128;
109/* Tablespace dictionary Index. Set only in in-memory index structure. */
110constexpr uint32_t DICT_SDI = 256;
111/** Multi-value index */
112constexpr uint32_t DICT_MULTI_VALUE = 512;
113
114/** number of bits used for SYS_INDEXES.TYPE */
115constexpr uint32_t DICT_IT_BITS = 10;
116/** @} */
117
118#if 0 /* not implemented, retained for history */
119/** Types for a table object */
120#define DICT_TABLE_ORDINARY 1 /*!< ordinary table */
121#define DICT_TABLE_CLUSTER_MEMBER 2
122#define DICT_TABLE_CLUSTER \
123 3 /* this means that the table is \
124really a cluster definition */
125#endif
126
127/* Table and tablespace flags are generally not used for the Antelope file
128format except for the low order bit, which is used differently depending on
129where the flags are stored.
130
131==================== Low order flags bit =========================
132 | REDUNDANT | COMPACT | COMPRESSED and DYNAMIC
133SYS_TABLES.TYPE | 1 | 1 | 1
134dict_table_t::flags | 0 | 1 | 1
135FSP_SPACE_FLAGS | 0 | 0 | 1
136fil_space_t::flags | 0 | 0 | 1
137
138Before the 5.1 plugin, SYS_TABLES.TYPE was always DICT_TABLE_ORDINARY (1)
139and the tablespace flags field was always 0. In the 5.1 plugin, these fields
140were repurposed to identify compressed and dynamic row formats.
141
142The following types and constants describe the flags found in dict_table_t
143and SYS_TABLES.TYPE. Similar flags found in fil_space_t and FSP_SPACE_FLAGS
144are described in fsp0fsp.h. */
145
146/** @{ */
147/** dict_table_t::flags bit 0 is equal to 0 if the row format = Redundant */
148/** Redundant row format. */
149constexpr uint32_t DICT_TF_REDUNDANT = 0;
150/** dict_table_t::flags bit 0 is equal to 1 if the row format = Compact */
151/** Compact row format. */
152constexpr uint32_t DICT_TF_COMPACT = 1;
153
154/** This bitmask is used in SYS_TABLES.N_COLS to set and test whether
155the Compact page format is used, i.e ROW_FORMAT != REDUNDANT */
156constexpr uint32_t DICT_N_COLS_COMPACT = 0x80000000UL;
157
158/** Width of the COMPACT flag */
159constexpr uint32_t DICT_TF_WIDTH_COMPACT = 1;
160
161/** Width of the ZIP_SSIZE flag */
162constexpr uint32_t DICT_TF_WIDTH_ZIP_SSIZE = 4;
163
164/** Width of the ATOMIC_BLOBS flag. The ROW_FORMAT=REDUNDANT and
165ROW_FORMAT=COMPACT broke up BLOB and TEXT fields, storing the first 768 bytes
166in the clustered index. ROW_FORMAT=DYNAMIC and ROW_FORMAT=COMPRESSED
167store the whole blob or text field off-page atomically.
168Secondary indexes are created from this external data using row_ext_t
169to cache the BLOB prefixes. */
170constexpr uint32_t DICT_TF_WIDTH_ATOMIC_BLOBS = 1;
171
172/** If a table is created with the MYSQL option DATA DIRECTORY and
173innodb-file-per-table, an older engine will not be able to find that table.
174This flag prevents older engines from attempting to open the table and
175allows InnoDB to update_create_info() accordingly. */
176constexpr uint32_t DICT_TF_WIDTH_DATA_DIR = 1;
177
178/** Width of the SHARED tablespace flag.
179It is used to identify tables that exist inside a shared general tablespace.
180If a table is created with the TABLESPACE=tsname option, an older engine will
181not be able to find that table. This flag prevents older engines from attempting
182to open the table and allows InnoDB to quickly find the tablespace. */
183
184constexpr uint32_t DICT_TF_WIDTH_SHARED_SPACE = 1;
185
186/** Width of all the currently known table flags */
187constexpr uint32_t DICT_TF_BITS =
191
192/** A mask of all the known/used bits in table flags */
193constexpr uint32_t DICT_TF_BIT_MASK = ~(~0U << DICT_TF_BITS);
194
195/** Zero relative shift position of the COMPACT field */
196constexpr uint32_t DICT_TF_POS_COMPACT = 0;
197/** Zero relative shift position of the ZIP_SSIZE field */
198constexpr uint32_t DICT_TF_POS_ZIP_SSIZE =
200/** Zero relative shift position of the ATOMIC_BLOBS field */
201constexpr uint32_t DICT_TF_POS_ATOMIC_BLOBS =
203/** Zero relative shift position of the DATA_DIR field */
204constexpr uint32_t DICT_TF_POS_DATA_DIR =
206/** Zero relative shift position of the SHARED TABLESPACE field */
207constexpr uint32_t DICT_TF_POS_SHARED_SPACE =
209/** Zero relative shift position of the start of the UNUSED bits */
210constexpr uint32_t DICT_TF_POS_UNUSED =
212
213/** Bit mask of the COMPACT field */
214constexpr uint32_t DICT_TF_MASK_COMPACT = (~(~0U << DICT_TF_WIDTH_COMPACT))
216/** Bit mask of the ZIP_SSIZE field */
219/** Bit mask of the ATOMIC_BLOBS field */
220constexpr uint32_t DICT_TF_MASK_ATOMIC_BLOBS =
222/** Bit mask of the DATA_DIR field */
223constexpr uint32_t DICT_TF_MASK_DATA_DIR = (~(~0U << DICT_TF_WIDTH_DATA_DIR))
225/** Bit mask of the SHARED_SPACE field */
226constexpr uint32_t DICT_TF_MASK_SHARED_SPACE =
228
229/** Return the value of the COMPACT field */
230inline uint32_t DICT_TF_GET_COMPACT(uint32_t flags) {
232}
233/** Return the value of the ZIP_SSIZE field */
234inline uint32_t DICT_TF_GET_ZIP_SSIZE(uint32_t flags) {
236}
237/** Return the value of the ATOMIC_BLOBS field */
238inline uint32_t DICT_TF_HAS_ATOMIC_BLOBS(uint32_t flags) {
240}
241/** Return the value of the DATA_DIR field */
242inline uint32_t DICT_TF_HAS_DATA_DIR(uint32_t flags) {
244}
245/** Return the value of the SHARED_SPACE field */
246inline uint32_t DICT_TF_HAS_SHARED_SPACE(uint32_t flags) {
248}
249/** Return the contents of the UNUSED bits */
250inline uint32_t DICT_TF_GET_UNUSED(uint32_t flags) {
251 return flags >> DICT_TF_POS_UNUSED;
252}
253/** @} */
254
255/** @brief Table Flags set number 2.
256
257These flags will be stored in SYS_TABLES.MIX_LEN. All unused flags
258will be written as 0. The column may contain garbage for tables
259created with old versions of InnoDB that only implemented
260ROW_FORMAT=REDUNDANT. InnoDB engines do not check these flags
261for unknown bits in order to protect backward incompatibility. */
262/** @{ */
263/** Total number of bits in table->flags2. */
264constexpr uint32_t DICT_TF2_BITS = 11;
265constexpr uint32_t DICT_TF2_UNUSED_BIT_MASK = ~0U << DICT_TF2_BITS;
266constexpr uint32_t DICT_TF2_BIT_MASK = ~DICT_TF2_UNUSED_BIT_MASK;
267
268/** TEMPORARY; true for tables from CREATE TEMPORARY TABLE. */
269constexpr uint32_t DICT_TF2_TEMPORARY = 1;
270
271/** The table has an internal defined DOC ID column */
272constexpr uint32_t DICT_TF2_FTS_HAS_DOC_ID = 2;
273
274/** The table has an FTS index */
275constexpr uint32_t DICT_TF2_FTS = 4;
276
277/** Need to add Doc ID column for FTS index build.
278This is a transient bit for index build */
279constexpr uint32_t DICT_TF2_FTS_ADD_DOC_ID = 8;
280
281/** This bit is used during table creation to indicate that it will
282use its own tablespace instead of the system tablespace. */
283constexpr uint32_t DICT_TF2_USE_FILE_PER_TABLE = 16;
284
285/** Set when we discard/detach the tablespace */
286constexpr uint32_t DICT_TF2_DISCARDED = 32;
287
288/** Intrinsic table bit
289Intrinsic table is table created internally by MySQL modules viz. Optimizer,
290FTS, etc.... Intrinsic table has all the properties of the normal table except
291it is not created by user and so not visible to end-user. */
292constexpr uint32_t DICT_TF2_INTRINSIC = 128;
293
294/** Encryption table bit for innodb_file-per-table only. */
295constexpr uint32_t DICT_TF2_ENCRYPTION_FILE_PER_TABLE = 256;
296
297/** FTS AUX hidden table bit. */
298constexpr uint32_t DICT_TF2_AUX = 512;
299
300/** Table is opened by resurrected trx during crash recovery. */
301constexpr uint32_t DICT_TF2_RESURRECT_PREPARED = 1024;
302/** @} */
303
304/** Tables could be chained together with Foreign key constraint. When
305first load the parent table, we would load all of its descedents.
306This could result in rescursive calls and out of stack error eventually.
307DICT_FK_MAX_RECURSIVE_LOAD defines the maximum number of recursive loads,
308when exceeded, the child table will not be loaded. It will be loaded when
309the foreign constraint check needs to be run. */
310constexpr uint32_t DICT_FK_MAX_RECURSIVE_LOAD = 20;
311
312/** Similarly, when tables are chained together with foreign key constraints
313with on cascading delete/update clause, delete from parent table could
314result in recursive cascading calls. This defines the maximum number of
315such cascading deletes/updates allowed. When exceeded, the delete from
316parent table will fail, and user has to drop excessive foreign constraint
317before proceeds. */
318constexpr uint32_t FK_MAX_CASCADE_DEL = 15;
319
320/** Adds a virtual column definition to a table.
321@param[in,out] table table
322@param[in] heap temporary memory heap, or NULL. It is
323 used to store name when we have not finished
324 adding all columns. When all columns are
325 added, the whole name will copy to memory from
326 table->heap
327@param[in] name column name
328@param[in] mtype main datatype
329@param[in] prtype precise type
330@param[in] len length
331@param[in] pos position in a table
332@param[in] num_base number of base columns
333@param[in] is_visible True if virtual column is visible to user
334@return the virtual column definition */
336 const char *name, ulint mtype,
337 ulint prtype, ulint len, ulint pos,
338 ulint num_base, bool is_visible);
339
340/** Adds a stored column definition to a table.
341@param[in,out] table table
342@param[in] num_base number of base columns. */
344
345/** Renames a column of a table in the data dictionary cache.
346@param[in,out] table Table
347@param[in] nth_col Column index
348@param[in] from Old column name
349@param[in] to New column name
350@param[in] is_virtual If this is a virtual column */
352 const char *from, const char *to,
353 bool is_virtual);
354
355/** This function poplulates a dict_index_t index memory structure with
356supplied information.
357@param[out] index index to be filled
358@param[in] heap memory heap
359@param[in] table_name table name
360@param[in] index_name index name
361@param[in] space space where the index tree is placed, the
362 clustered type ignored if the index is of
363the clustered type
364@param[in] type DICT_UNIQUE, DICT_CLUSTERED, ... ORed
365@param[in] n_fields number of fields */
366static inline void dict_mem_fill_index_struct(
367 dict_index_t *index, mem_heap_t *heap, const char *table_name,
368 const char *index_name, ulint space, ulint type, ulint n_fields);
369
370/** Frees an index memory object. */
371void dict_mem_index_free(dict_index_t *index); /*!< in: index */
372/** Creates and initializes a foreign constraint memory object.
373 @return own: foreign constraint struct */
375
376/** Sets the foreign_table_name_lookup pointer based on the value of
377 lower_case_table_names. If that is 0 or 1, foreign_table_name_lookup
378 will point to foreign_table_name. If 2, then another string is
379 allocated from the heap and set to lower case. */
381 dict_foreign_t *foreign, /*!< in/out: foreign struct */
382 bool do_alloc); /*!< in: is an alloc needed */
383
384/** Sets the referenced_table_name_lookup pointer based on the value of
385 lower_case_table_names. If that is 0 or 1, referenced_table_name_lookup
386 will point to referenced_table_name. If 2, then another string is
387 allocated from the heap and set to lower case. */
389 dict_foreign_t *foreign, /*!< in/out: foreign struct */
390 bool do_alloc); /*!< in: is an alloc needed */
391
392/** Fills the dependent virtual columns in a set.
393Reason for being dependent are
3941) FK can be present on base column of virtual columns
3952) FK can be present on column which is a part of virtual index
396@param[in,out] foreign foreign key information. */
398
399/** Fill virtual columns set in each fk constraint present in the table.
400@param[in,out] table innodb table object. */
402
403/** Free the vcol_set from all foreign key constraint on the table.
404@param[in,out] table innodb table object. */
406
407/** Create a temporary tablename like "#sql-ibtid-inc" where
408 tid = the Table ID
409 inc = a randomly initialized number that is incremented for each file
410The table ID is a 64 bit integer, can use up to 20 digits, and is
411initialized at bootstrap. The second number is 32 bits, can use up to 10
412digits, and is initialized at startup to a randomly distributed number.
413It is hoped that the combination of these two numbers will provide a
414reasonably unique temporary file name.
415@param[in] heap A memory heap
416@param[in] dbtab Table name in the form database/table name
417@param[in] id Table id
418@return A unique temporary tablename suitable for InnoDB use */
419char *dict_mem_create_temporary_tablename(mem_heap_t *heap, const char *dbtab,
420 table_id_t id);
421
422static inline bool is_valid_row_version(const row_version_t version) {
423 /* NOTE : 0 is also a valid row versions for rows which are inserted after
424 upgrading from earlier INSTANT implemenation */
425 if (std::cmp_less_equal(version, MAX_ROW_VERSION)) {
426 return true;
427 }
428
429 return false;
430}
431
432/** Initialize dict memory variables */
433void dict_mem_init(void);
434
435/** SQL identifier name wrapper for pretty-printing */
437 public:
438 /** Default constructor */
440 /** Constructor
441 @param[in] name identifier to assign */
442 explicit id_name_t(const char *name) : m_name(name) {}
443
444 /** Assignment operator
445 @param[in] name identifier to assign */
446 id_name_t &operator=(const char *name) {
447 m_name = name;
448 return (*this);
449 }
450
451 /** Implicit type conversion
452 @return the name */
453 operator const char *() const { return (m_name); }
454
455 /** Explicit type conversion
456 @return the name */
457 const char *operator()() const { return (m_name); }
458
459 private:
460 /** The name in internal representation */
461 const char *m_name;
462};
463
464/** Table name wrapper for pretty-printing */
466 /** The name in internal representation */
467 char *m_name;
468};
469
470/** Data structure for default value of a column in a table */
472 /** Pointer to the column itself */
474 /** Default value in bytes */
475 byte *value;
476 /** Length of default value */
477 size_t len;
478
479 bool operator==(const dict_col_default_t &other) const;
480 bool operator!=(const dict_col_default_t &other) const;
481};
482
483/** Data structure for a column in a table */
485 /*----------------------*/
486 /** The following are copied from dtype_t,
487 so that all bit-fields can be packed tightly. */
488 /** @{ */
489
490 /** Default value when this column was added instantly.
491 If this is not a instantly added column then this is nullptr. */
493
494 unsigned prtype : 32; /*!< precise type; MySQL data
495 type, charset code, flags to
496 indicate nullability,
497 signedness, whether this is a
498 binary string, whether this is
499 a true VARCHAR where MySQL
500 uses 2 bytes to store the length */
501 unsigned mtype : 8; /*!< main data type */
502
503 /* the remaining fields do not affect alphabetical ordering: */
504
505 unsigned len : 16; /*!< length; for MySQL data this
506 is field->pack_length(),
507 except that for a >= 5.0.3
508 type true VARCHAR this is the
509 maximum byte length of the
510 string data (in addition to
511 the string, MySQL uses 1 or 2
512 bytes to store the string length) */
513
514 unsigned mbminmaxlen : 5; /*!< minimum and maximum length of a
515 character, in bytes;
516 DATA_MBMINMAXLEN(mbminlen,mbmaxlen);
517 mbminlen=DATA_MBMINLEN(mbminmaxlen);
518 mbmaxlen=DATA_MBMINLEN(mbminmaxlen) */
519 /*----------------------*/
520 /* End of definitions copied from dtype_t */
521 /** @} */
522
523 unsigned ind : 10; /*!< table column position
524 (starting from 0) */
525 unsigned ord_part : 1; /*!< nonzero if this column
526 appears in the ordering fields
527 of an index */
528 unsigned max_prefix : 12; /*!< maximum index prefix length on
529 this column. Our current max limit is
530 3072 (REC_VERSION_56_MAX_INDEX_COL_LEN)
531 bytes. */
532
533 /* True, if the column is visible */
535
536 private:
537 /* Position of column on physical row.
538 If column prefix is part of PK, it appears twice on row. First 2 bytes are
539 for prefix position and next 2 bytes are for column position on row. */
541
542 /* Row version in which this column was added INSTANTly to the table */
544
545 /* Row version in which this column was dropped INSTANTly from the table */
547
548 public:
549 /* If column prefix is there on row. */
550 bool has_prefix_phy_pos() const { return (phy_pos & 0x8000); }
551
552 /* Get the physical position of column prefix on row. */
553 uint16_t get_prefix_phy_pos() const {
555 return ((uint16_t)(phy_pos >> 16));
556 }
557
558 /* Set the physical position of column prefix on row. */
559 void set_prefix_phy_pos(uint16_t prefix_pos) {
560 phy_pos = prefix_pos;
561 phy_pos = phy_pos << 16;
562 phy_pos |= 0x8000;
563 }
564
565 /* Get the physical position of column on row. */
566 uint16_t get_col_phy_pos() const { return ((phy_pos & ~0x8000) & 0xFFFF); }
567
568 /* Set the physical position of column on row. */
569 void set_col_phy_pos(uint16_t pos) {
571 phy_pos |= pos;
572 }
573
574 /* Set the physical position metadata of column. */
575 uint32_t get_phy_pos() const { return phy_pos; }
576
577 /* Get the physical position metadata of column. */
578 void set_phy_pos(uint32_t pos) { phy_pos = pos; }
579
580 bool is_instant_added() const {
582 return true;
583 }
584 return false;
585 }
586
589 return version_added;
590 }
591
595 }
596
597 bool is_version_added_match(const dict_col_t *col) const {
598 if (is_instant_added() != col->is_instant_added()) {
599 return false;
600 }
601
602 if (is_instant_added()) {
603 return (get_version_added() == col->get_version_added());
604 }
605
606 return true;
607 }
608
609 bool is_instant_dropped() const {
611 return true;
612 }
613 return false;
614 }
615
618 return version_dropped;
619 }
620
624 }
625
626 bool is_version_dropped_match(const dict_col_t *col) const {
627 if (is_instant_dropped() != col->is_instant_dropped()) {
628 return false;
629 }
630
631 if (is_instant_dropped()) {
632 return (get_version_dropped() == col->get_version_dropped());
633 }
634
635 return true;
636 }
637
638 /** Returns the minimum size of the column.
639 @return minimum size */
642 }
643
644 /** Returns the maximum size of the column.
645 @return maximum size */
647
648 /** Check if a column is a virtual column
649 @return true if it is a virtual column, false otherwise */
650 bool is_virtual() const { return (prtype & DATA_VIRTUAL); }
651
652 /** Check if a column is a multi-value virtual column
653 @return true if it is a multi-value virtual column, false otherwise */
654 bool is_multi_value() const { return ((prtype & DATA_MULTI_VALUE) != 0); }
655
656 /** Check if a column is nullable
657 @return true if it is nullable, otherwise false */
658 bool is_nullable() const { return ((prtype & DATA_NOT_NULL) == 0); }
659
660 /** Gets the column data type.
661 @param[out] type data type */
662 void copy_type(dtype_t *type) const {
663 ut_ad(type != nullptr);
664
665 type->mtype = mtype;
666 type->prtype = prtype;
667 type->len = len;
668 type->mbminmaxlen = mbminmaxlen;
669 }
670
671 /** Gets the minimum number of bytes per character.
672 @return minimum multi-byte char size, in bytes */
674
675 /** Gets the maximum number of bytes per character.
676 @return maximum multi-byte char size, in bytes */
678
679 /** Sets the minimum and maximum number of bytes per character.
680 @param[in] mbminlen minimum multi byte character size, in bytes
681 @param[in] mbmaxlen mAXimum multi-byte character size, in bytes */
682 void set_mbminmaxlen(ulint mbminlen, ulint mbmaxlen) {
683 ut_ad(mbminlen < DATA_MBMAX);
684 ut_ad(mbmaxlen < DATA_MBMAX);
685 ut_ad(mbminlen <= mbmaxlen);
686
687 mbminmaxlen = DATA_MBMINMAXLEN(mbminlen, mbmaxlen);
688 }
689
690 /** Returns the size of a fixed size column, 0 if not a fixed size column.
691 @param[in] comp nonzero=ROW_FORMAT=COMPACT
692 @return fixed size, or 0 */
695 }
696
697 /** Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a column.
698 For fixed length types it is the fixed length of the type, otherwise 0.
699 @param[in] comp nonzero=ROW_FORMAT=COMPACT
700 @return SQL null storage size in ROW_FORMAT=REDUNDANT */
701 ulint get_null_size(ulint comp) const { return (get_fixed_size(comp)); }
702
703 /** Check whether the col is used in spatial index or regular index.
704 @return spatial status */
706 spatial_status_t spatial_status = SPATIAL_NONE;
707
708 /* Column is not a part of any index. */
709 if (!ord_part) {
710 return (spatial_status);
711 }
712
714 if (max_prefix == 0) {
715 spatial_status = SPATIAL_ONLY;
716 } else {
717 /* Any regular index on a geometry column
718 should have a prefix. */
719 spatial_status = SPATIAL_MIXED;
720 }
721 }
722
723 return (spatial_status);
724 }
725
726 /** Set default value
727 @param[in] value Default value
728 @param[in] length Default value length
729 @param[in,out] heap Heap to allocate memory */
730 void set_default(const byte *value, size_t length, mem_heap_t *heap);
731
732 /** Check if column is dropped before the given version.
733 @param[in] version row version
734 @return true if the column is dropped before or in the version. */
737
738 if (!is_instant_dropped()) {
739 return false;
740 }
741
742 return (get_version_dropped() <= version);
743 }
744
745 /** Check if column is added after the current version.
746 @param[in] version row version
747 @return true if column is added after the current row version. */
750
751 if (!is_instant_added()) {
752 return false;
753 }
754
755 return (get_version_added() > version);
756 }
757
758 /** Check if a column is visible in given version.
759 @param[in] version row version
760 return true if column is visible in version. */
764 }
765
766#ifdef UNIV_DEBUG
767 /** Assert that a column and a data type match.
768 param[in] type data type
769 @return true */
770 bool assert_equal(const dtype_t *type) const {
771 ut_ad(type);
772
773 ut_ad(mtype == type->mtype);
774 ut_ad(prtype == type->prtype);
775 // ut_ad(col->len == type->len);
776#ifndef UNIV_HOTBACKUP
777 ut_ad(mbminmaxlen == type->mbminmaxlen);
778#endif /* !UNIV_HOTBACKUP */
779
780 return true;
781 }
782
783 /** Check if a column name resembles format for dropped column.
784 param[in] type column name
785 @return true if column name resembles dropped column. */
786 static bool is_instant_dropped_name(const std::string col_name) {
787 if (col_name.find(INSTANT_DROP_SUFFIX_8_0_29) != std::string::npos ||
788 col_name.find(INSTANT_DROP_PREFIX_8_0_32) != std::string::npos)
789 return true;
790 return false;
791 }
792#endif /* UNIV_DEBUG */
793};
794
795/** Index information put in a list of virtual column structure. Index
796id and virtual column position in the index will be logged.
797There can be multiple entries for a given index, with a different position. */
799 /** active index on the column */
801
802 /** position in this index */
804};
805
806/** Index list to put in dict_v_col_t */
807typedef std::list<dict_v_idx_t, ut::allocator<dict_v_idx_t>> dict_v_idx_list;
808
809/** Data structure for a virtual column in a table */
811 /** column structure */
813
814 /** array of base column ptr */
816
817 /** number of base columns */
819
820 /** column pos in table */
822
823 /** Virtual index list, and column position in the index,
824 the allocated memory is not from table->heap, nor it is
825 tracked by dict_sys->size */
827};
828
829/** Data structure for newly added virtual column in a table */
831 /** number of new virtual column */
833
834 /** column structures */
836
837 /** new col names */
838 const char **v_col_name;
839};
840
841/** Data structure for a stored column in a table. */
843 /** Stored column ptr */
845 /** array of base col ptr */
847 /** number of base columns */
849 /** column pos in table */
851};
852
853/** list to put stored column for dict_table_t */
854typedef std::list<dict_s_col_t, ut::allocator<dict_s_col_t>> dict_s_col_list;
855
856/** @brief DICT_ANTELOPE_MAX_INDEX_COL_LEN is measured in bytes and
857is the maximum indexed column length (or indexed prefix length) in
858ROW_FORMAT=REDUNDANT and ROW_FORMAT=COMPACT. Also, in any format,
859any fixed-length field that is longer than this will be encoded as
860a variable-length field.
861
862It is set to 3*256, so that one can create a column prefix index on
863256 characters of a TEXT or VARCHAR column also in the UTF-8
864charset. In that charset, a character may take at most 3 bytes. This
865constant MUST NOT BE CHANGED, or the compatibility of InnoDB data
866files would be at risk! */
869
870/** Find out maximum indexed column length by its table format.
871For ROW_FORMAT=REDUNDANT and ROW_FORMAT=COMPACT, the maximum
872field length is REC_ANTELOPE_MAX_INDEX_COL_LEN - 1 (767). For
873ROW_FORMAT=COMPRESSED and ROW_FORMAT=DYNAMIC, the length could
874be REC_VERSION_56_MAX_INDEX_COL_LEN (3072) bytes */
875#define DICT_MAX_FIELD_LEN_BY_FORMAT(table) \
876 (dict_table_has_atomic_blobs(table) ? REC_VERSION_56_MAX_INDEX_COL_LEN \
877 : REC_ANTELOPE_MAX_INDEX_COL_LEN - 1)
878
879static inline uint32_t DICT_MAX_FIELD_LEN_BY_FORMAT_FLAG(uint32_t flags) {
882 }
884}
885
886/** Defines the maximum fixed length column size */
888
889/** Data structure for a field in an index */
892
893 dict_col_t *col; /*!< pointer to the table column */
894 id_name_t name; /*!< name of the column */
895 unsigned prefix_len : 12; /*!< 0 or the length of the column
896 prefix in bytes in a MySQL index of
897 type, e.g., INDEX (textcol(25));
898 must be smaller than
899 DICT_MAX_FIELD_LEN_BY_FORMAT;
900 NOTE that in the UTF-8 charset, MySQL
901 sets this to (mbmaxlen * the prefix len)
902 in UTF-8 chars */
903 unsigned fixed_len : 10; /*!< 0 or the fixed length of the
904 column if smaller than
905 DICT_ANTELOPE_MAX_INDEX_COL_LEN */
906 unsigned is_ascending : 1; /*!< 0=DESC, 1=ASC */
907
908 uint16_t get_phy_pos() const {
909 if (prefix_len != 0) {
910 return col->get_prefix_phy_pos();
911 }
912
913 return col->get_col_phy_pos();
914 }
915};
916
917/** PADDING HEURISTIC BASED ON LINEAR INCREASE OF PADDING TO AVOID
918 COMPRESSION FAILURES
919 (Note: this is relevant only for compressed indexes)
920 GOAL: Avoid compression failures by maintaining information about the
921 compressibility of data. If data is not very compressible then leave
922 some extra space 'padding' in the uncompressed page making it more
923 likely that compression of less than fully packed uncompressed page will
924 succeed.
925
926 This padding heuristic works by increasing the pad linearly until the
927 desired failure rate is reached. A "round" is a fixed number of
928 compression operations.
929 After each round, the compression failure rate for that round is
930 computed. If the failure rate is too high, then padding is incremented
931 by a fixed value, otherwise it's left intact.
932 If the compression failure is lower than the desired rate for a fixed
933 number of consecutive rounds, then the padding is decreased by a fixed
934 value. This is done to prevent overshooting the padding value,
935 and to accommodate the possible change in data compressibility. */
936
937/** Number of zip ops in one round. */
938constexpr uint32_t ZIP_PAD_ROUND_LEN = 128;
939
940/** Number of successful rounds after which the padding is decreased */
941constexpr uint32_t ZIP_PAD_SUCCESSFUL_ROUND_LIMIT = 5;
942
943/** Amount by which padding is increased. */
944constexpr uint32_t ZIP_PAD_INCR = 128;
945
946/** Percentage of compression failures that are allowed in a single
947round */
948extern ulong zip_failure_threshold_pct;
949
950/** Maximum percentage of a page that can be allowed as a pad to avoid
951compression failures */
952extern ulong zip_pad_max;
953
954/** Data structure to hold information about about how much space in
955an uncompressed page should be left as padding to avoid compression
956failures. This estimate is based on a self-adapting heuristic. */
958 SysMutex *mutex; /*!< mutex protecting the info */
959 std::atomic<ulint> pad; /*!< number of bytes used as pad */
960 ulint success; /*!< successful compression ops during
961 current round */
962 ulint failure; /*!< failed compression ops during
963 current round */
964 ulint n_rounds; /*!< number of currently successful
965 rounds */
966#ifndef UNIV_HOTBACKUP
967 std::atomic<os_once::state_t> mutex_created;
968 /*!< Creation state of mutex member */
969#endif /* !UNIV_HOTBACKUP */
970};
971
972/** If key is fixed length key then cache the record offsets on first
973computation. This will help save computation cycle that generate same
974redundant data. */
976 /** Holds reference to cached offsets for record. */
977 const ulint *offsets{nullptr};
978
979 /** Number of NULLable columns among those for which offsets are cached */
980 size_t nullable_cols{0};
981};
982
983/** Cache position of last inserted or selected record by caching record
984and holding reference to the block where record resides.
985Note: We don't commit mtr and hold it beyond a transaction lifetime as this is
986a special case (intrinsic table) that are not shared across connection. */
988 public:
989 /** Constructor */
991 /* Do Nothing. */
992 }
993
994 /* Commit mtr and re-initialize cache record and block to NULL. */
995 void release() {
996 if (mtr.is_active()) {
997 mtr_commit(&mtr);
998 }
999 rec = nullptr;
1000 block = nullptr;
1001 invalid = false;
1002 }
1003
1004 public:
1005 /** last inserted/selected record. */
1007
1008 /** block where record reside. */
1010
1011 /** active mtr that will be re-used for next insert/select. */
1013
1014 /** disable caching. (disabled when table involves blob/text.) */
1016
1017 /** If index structure is undergoing structural change viz.
1018 split then invalidate the cached position as it would be no more
1019 remain valid. Will be re-cached on post-split insert. */
1021};
1022
1023/** "GEN_CLUST_INDEX" is the name reserved for InnoDB default
1024system clustered index when there is no primary key. */
1025const char innobase_index_reserve_name[] = "GEN_CLUST_INDEX";
1026
1027namespace dd {
1028class Spatial_reference_system;
1029}
1030
1031#ifdef UNIV_DEBUG
1032/** Value of dict_index_t::magic_n */
1033constexpr uint32_t DICT_INDEX_MAGIC_N = 76789786;
1034#endif
1035
1037constexpr uint32_t MAX_KEY_LENGTH_BITS = 12;
1038
1039/** Data structure for an index. Most fields will be
1040initialized to 0, NULL or false in dict_mem_index_create(). */
1042 /** id of the index */
1044
1045 /** memory heap */
1047
1048 /** index name */
1050
1051 /** table name */
1052 const char *table_name;
1053
1054 /** back pointer to table */
1056
1057 /** space where the index tree is placed */
1058 unsigned space : 32;
1059
1060 /** index tree root page number */
1061 unsigned page : 32;
1062
1063 /** In the pessimistic delete, if the page data size drops below this limit
1064 in percent, merging it to a neighbor is tried */
1065 unsigned merge_threshold : 6;
1066
1067 /** index type (DICT_CLUSTERED, DICT_UNIQUE, DICT_IBUF, DICT_CORRUPT) */
1068 unsigned type : DICT_IT_BITS;
1069
1070 /** position of the trx id column in a clustered index record, if the fields
1071 before it are known to be of a fixed size, 0 otherwise */
1073
1074 static_assert(1 << MAX_KEY_LENGTH_BITS >= MAX_KEY_LENGTH,
1075 "1<<MAX_KEY_LENGTH_BITS) < MAX_KEY_LENGTH");
1076
1077 /** number of columns the user defined to be in the index: in the internal
1078 representation we add more columns */
1079 unsigned n_user_defined_cols : 10;
1080
1081 /** if true, allow duplicate values even if index is created with unique
1082 constraint */
1083 unsigned allow_duplicates : 1;
1084
1085 /** if true, SQL NULL == SQL NULL */
1086 unsigned nulls_equal : 1;
1087
1088 /** if true, then disable AHI. Currently limited to intrinsic temporary table
1089 and SDI table as index id is not unique for such table which is one of the
1090 validation criterion for ahi. */
1091 unsigned disable_ahi : 1;
1092
1093 /** number of fields from the beginning which are enough to determine an index
1094 entry uniquely */
1095 unsigned n_uniq : 10;
1096
1097 /** number of fields defined so far */
1098 unsigned n_def : 10;
1099
1100 /** number of fields in the index */
1101 unsigned n_fields : 10;
1102
1103 /** number of total fields in the index (including INSTANT dropped fields) */
1104 unsigned n_total_fields : 10;
1105
1106 /** number of nullable fields */
1107 unsigned n_nullable : 10;
1108
1109 /** number of nullable fields before first instant ADD COLUMN applied to this
1110 table. This is valid only when has_instant_cols() is true */
1111 unsigned n_instant_nullable : 10;
1112
1113 /** true if the index object is in the dictionary cache */
1114 unsigned cached : 1;
1115
1116 /** true if the index is to be dropped; protected by dict_operation_lock */
1117 unsigned to_be_dropped : 1;
1118
1119 /** enum online_index_status. Transitions from ONLINE_INDEX_COMPLETE (to
1120 ONLINE_INDEX_CREATION) are protected by dict_operation_lock and
1121 dict_sys->mutex. Other changes are protected by index->lock. */
1122 unsigned online_status : 2;
1123
1124 /** a flag that is set for secondary indexes that have not been committed to
1125 the data dictionary yet */
1126 unsigned uncommitted : 1;
1127
1128 /** true if the index is clustered index and it has some instant columns */
1129 unsigned instant_cols : 1;
1130
1131 /** true if the index is clustered index and table has row versions */
1132 unsigned row_versions : 1;
1133
1134 /** spatial reference id */
1135 uint32_t srid;
1136
1137 /** says whether SRID is valid - it cane be undefined */
1139
1140 /** Cached spatial reference system dictionary entry used by R-tree indexes.
1141 */
1142 std::unique_ptr<dd::Spatial_reference_system> rtr_srs;
1143
1144#ifdef UNIV_DEBUG
1145 uint32_t magic_n; /*!< magic number */
1146#endif
1147
1148 /** array of field descriptions */
1150
1151 /** Array of field pos sorted as per their physical pos in record. Only
1152 needed for clustered index having INSTANT ADD/DROP columns. */
1153 std::vector<uint16_t> fields_array;
1154
1155 /** Number of nullable columns in each version. Only needed for clustered
1156 index having INSTANT ADD/DROP columns. */
1157 uint32_t nullables[MAX_ROW_VERSION + 1] = {0};
1158
1159#ifndef UNIV_HOTBACKUP
1160 /** fulltext parser plugin */
1162
1163 /** true if it's ngram parser */
1165
1166 /** whether it has a newly added virtual column in ALTER */
1168
1169 /** if the index is an hidden index */
1171#endif /* !UNIV_HOTBACKUP */
1172
1173 /** list of indexes of the table */
1175
1176 /** info used in optimistic searches */
1178
1179#ifndef UNIV_HOTBACKUP
1180 /** the log of modifications during online index creation;
1181 valid when online_status is ONLINE_INDEX_CREATION */
1183
1184 /*----------------------*/
1185 /** Statistics for query optimization */
1186 /** @{ */
1187 /** approximate number of different key values for this index, for each
1188 n-column prefix where 1 <= n <= dict_get_n_unique(index) (the array is
1189 indexed from 0 to n_uniq-1); we periodically calculate new estimates */
1191
1192 /** number of pages that were sampled to calculate each of
1193 stat_n_diff_key_vals[], e.g. stat_n_sample_sizes[3] pages were sampled to get
1194 the number stat_n_diff_key_vals[3]. */
1196
1197 /* approximate number of non-null key values for this index, for each column
1198 where 1 <= n <= dict_get_n_unique(index) (the array is indexed from 0 to
1199 n_uniq-1); This is used when innodb_stats_method is "nulls_ignored". */
1201
1202 /** approximate index size in database pages */
1204#endif /* !UNIV_HOTBACKUP */
1205 /** approximate number of leaf pages in the index tree */
1207 /** @} */
1208
1209 /** cache the last insert position. Currently limited to auto-generated
1210 clustered index on intrinsic table only. */
1212
1213 /** cache the last selected position. Currently limited to intrinsic table
1214 only. */
1216
1217 /** cache the field that needs to be re-computed on each insert. Limited to
1218 intrinsic table as this is common share and can't be used without protection
1219 if table is accessible to multiple-threads. */
1221
1222 /** Node sequence number for RTree */
1224
1225 /** tracking all R-Tree search cursors */
1227
1228 /** id of the transaction that created this index, or 0 if the index existed
1229 when InnoDB was started up */
1231
1232 /** Information about state of compression failures and successes */
1234
1235 /** read-write lock protecting the upper levels of the index tree */
1237
1238 /** Flag whether need to fill dd tables when it's a fulltext index. */
1240
1241 /** Set instant nullable
1242 @param[in] n nullable fields before first INSTANT ADD */
1244
1245 /** Get instant nullable.
1246 @return number of nullable fields before first INSTANT ADD */
1247 uint16_t get_instant_nullable() const { return n_instant_nullable; }
1248
1249 /** Get the nullable fields before any INSTANT ADD/DROP
1250 @return number of nullable fields */
1252 if (has_instant_cols()) {
1253 return get_instant_nullable();
1254 }
1255
1256 if (has_row_versions()) {
1257 return get_nullable_in_version(0);
1258 }
1259
1260 return n_nullable;
1261 }
1262
1263 /** Determine if the index has been committed to the
1264 data dictionary.
1265 @return whether the index definition has been committed */
1266 bool is_committed() const {
1268 return (UNIV_LIKELY(!uncommitted));
1269 }
1270
1271 /** Flag an index committed or uncommitted.
1272 @param[in] committed whether the index is committed */
1273 void set_committed(bool committed) {
1275 ut_ad(committed || !(type & DICT_CLUSTERED));
1276 uncommitted = !committed;
1277 }
1278
1279 /** Get the next index.
1280 @return next index
1281 @retval NULL if this was the last index */
1282 const dict_index_t *next() const {
1283 const dict_index_t *next = UT_LIST_GET_NEXT(indexes, this);
1285 return (next);
1286 }
1287 /** Get the next index.
1288 @return next index
1289 @retval NULL if this was the last index */
1291 return (const_cast<dict_index_t *>(
1292 const_cast<const dict_index_t *>(this)->next()));
1293 }
1294
1295 /** Check whether the index is corrupted.
1296 @return true if index is corrupted, otherwise false */
1297 bool is_corrupted() const {
1299
1300 return (type & DICT_CORRUPT);
1301 }
1302
1303 /* Check whether the index is the clustered index
1304 @return nonzero for clustered index, zero for other indexes */
1305
1306 bool is_clustered() const {
1308
1309 return (type & DICT_CLUSTERED);
1310 }
1311
1312 /** Check whether the index is the multi-value index
1313 @return nonzero for multi-value index, zero for other indexes */
1314 bool is_multi_value() const {
1316
1317 return (type & DICT_MULTI_VALUE);
1318 }
1319
1320 /** Returns the minimum data size of an index record.
1321 @return minimum data size in bytes */
1323 ulint size = 0;
1324
1325 for (unsigned i = 0; i < n_fields; i++) {
1326 size += get_col(i)->get_min_size();
1327 }
1328
1329 return (size);
1330 }
1331
1332 /** Check whether index can be used by transaction
1333 @param[in] trx transaction*/
1334 bool is_usable(const trx_t *trx) const;
1335
1336 /** Check whether index has any instantly added columns.
1337 Possible only if table has INSTANT ADD columns and is upgraded.
1338 @return true if this is instant affected, otherwise false */
1339 bool has_instant_cols() const { return (instant_cols); }
1340
1341 /** Check whether index belongs to a table having row versions
1342 @return true if table has row versions, otherwise false */
1343 bool has_row_versions() const { return (row_versions); }
1344
1345 /** check if either instant or versioned.
1346 @return true if table has row versions or instant cols, otherwise false */
1348 if (!is_clustered()) {
1350 return false;
1351 }
1352
1353 return (has_row_versions() || has_instant_cols());
1354 }
1355
1356 /** Check if tuple is having instant format.
1357 @param[in] n_fields_in_tuple number of fields in tuple
1358 @return true if yes, false otherwise. */
1359 bool is_tuple_instant_format(const uint16_t n_fields_in_tuple) const;
1360
1361 /** Returns the number of nullable fields before specified nth field
1362 @param[in] nth nth field to check */
1363 uint32_t get_n_nullable_before(uint32_t nth) const {
1364 uint32_t nullable = 0;
1365 ut_ad(nth <= n_total_fields);
1366
1367 for (size_t i = 0; i < nth; ++i) {
1368 dict_col_t *col = get_field(i)->col;
1369
1370 ut_ad(!col->is_instant_dropped());
1371
1372 if (col->is_nullable()) {
1373 nullable++;
1374 }
1375 }
1376
1377 return (nullable);
1378 }
1379
1380 /** Returns total fields including INSTANT DROP fields. */
1381 uint32_t get_n_total_fields() const {
1383 return n_total_fields;
1384 }
1385
1386 /** Returns the number of fields before first instant ADD COLUMN. This is
1387 needed only for V1 INSTANT ADD. */
1388 uint32_t get_instant_fields() const;
1389
1390 size_t calculate_n_instant_nullable(size_t _n_fields) const {
1391 if (!has_row_versions()) {
1393 return get_n_nullable_before(_n_fields);
1394 }
1395
1396 size_t n_drop_nullable_cols = 0;
1397 size_t new_n_nullable = 0;
1398 for (size_t i = 0; i < n_def; i++) {
1399 const dict_field_t *field = &fields[i];
1400 const dict_col_t *col = field->col;
1401
1402 if (col->is_instant_added()) {
1403 continue;
1404 }
1405
1406 if (col->is_instant_dropped()) {
1407 if (col->get_col_phy_pos() < _n_fields && col->is_nullable()) {
1408 n_drop_nullable_cols++;
1409 }
1410 continue;
1411 }
1412
1413 /* This is regular column */
1414 if (col->get_col_phy_pos() < _n_fields) {
1415 if (col->is_nullable()) {
1416 new_n_nullable++;
1417 }
1418 }
1419 }
1420
1421 new_n_nullable += n_drop_nullable_cols;
1422
1423 return new_n_nullable;
1424 }
1425
1426 /** Create nullables array.
1427 @param[in] current_row_version current row version of table */
1428 void create_nullables(uint32_t current_row_version);
1429
1430 /** Return nullable in a specific row version */
1433
1434 return nullables[version];
1435 }
1436
1437 /** Create fields array sorted by phy_pos of field in row */
1439 fields_array.resize(n_def);
1440 for (uint32_t i = 0; i < n_def; i++) {
1441 dict_field_t *field = get_field(i);
1442 ut_ad(field != nullptr && field->col != nullptr);
1443
1444 size_t pos = field->get_phy_pos();
1445
1446 fields_array[pos] = i;
1447 }
1448 }
1449
1451 /* The dict_index_t destructor is never called. The object is "destructed"
1452 manually in dict_mem_index_free() and then the memory is just freed. This
1453 method is called from the mentioned dict_mem_index_free(). Please note that
1454 this vector is never constructed either - we just zero the memory and start
1455 using it after calling a "constructor" dict_mem_fill_index_struct(). */
1456 fields_array.~vector<uint16_t>();
1457 }
1458
1459 /** Adds a field definition to an index. NOTE: does not take a copy
1460 of the column name if the field is a column. The memory occupied
1461 by the column name may be released only after publishing the index.
1462 @param[in] name_arg column name
1463 @param[in] prefix_len 0 or the column prefix length in a MySQL index
1464 like INDEX (textcol(25))
1465 @param[in] is_ascending true=ASC, false=DESC */
1466 void add_field(const char *name_arg, ulint prefix_len, bool is_ascending) {
1467 dict_field_t *field;
1468
1470
1471 n_def++;
1472
1473 field = get_field(n_def - 1);
1474
1475 field->name = name_arg;
1476 field->prefix_len = (unsigned int)prefix_len;
1477 field->is_ascending = is_ascending;
1478 }
1479
1480 /** Gets the nth physical pos field.
1481 @param[in] pos physical position of the field
1482 @return pointer to the field object. */
1484 ut_ad(pos < n_def);
1486
1487 if (has_row_versions()) {
1488 return get_field(fields_array[pos]);
1489 }
1490
1491 return get_field(pos);
1492 }
1493
1494 /** Gets the nth field of an index.
1495 @param[in] pos position of field
1496 @return pointer to field object */
1498 ut_ad(pos < n_def);
1500
1501 return (fields + pos);
1502 }
1503
1504 /** Given the physical position, find the logical position of field.
1505 @param[in] phy_pos physical position of field
1506 @return logical position of field */
1507 uint16_t get_logical_pos(uint16_t phy_pos) const {
1508 for (size_t i = 0; i < n_def; i++) {
1509 if (get_field(i)->get_phy_pos() == phy_pos) {
1510 return i;
1511 }
1512 }
1513 ut_ad(false);
1514 return UINT16_UNDEFINED;
1515 }
1516
1517 /** Get the physical position of a field on a row. For table having INSTANT
1518 column, it might differ from field index (pos).
1519 @param[in] pos field index
1520 @return physical position on row */
1521 uint16_t get_field_off_pos(ulint pos) const {
1522 return get_field(pos)->get_phy_pos();
1523 }
1524
1526 uint16_t phy_pos = get_field(pos)->get_phy_pos();
1528 return phy_pos;
1529 }
1530
1531 uint16_t res = phy_pos;
1532 for (size_t i = 0; i < phy_pos; i++) {
1533 if (get_field(fields_array[i])->col->is_dropped_in_or_before(version)) {
1534 res--;
1535 }
1536 }
1537
1538 return res;
1539 }
1540
1541 /** Gets pointer to the nth column in an index.
1542 @param[in] pos position of the field
1543 @return column */
1544 const dict_col_t *get_col(ulint pos) const { return (get_field(pos)->col); }
1545
1546 /** Gets the column number the nth field in an index.
1547 @param[in] pos position of the field
1548 @return column number */
1549 ulint get_col_no(ulint pos) const;
1550
1551 /** Returns the position of a system column in an index.
1552 @param[in] type DATA_ROW_ID, ...
1553 @return position, ULINT_UNDEFINED if not contained */
1555
1556 /** Looks for column n in an index.
1557 @param[in] n column number
1558 @param[in] inc_prefix true=consider column prefixes too
1559 @param[in] is_virtual true==virtual column
1560 @return position in internal representation of the index;
1561 ULINT_UNDEFINED if not contained */
1562 ulint get_col_pos(ulint n, bool inc_prefix = false,
1563 bool is_virtual = false) const;
1564
1565 /** Get the default value of nth field and its length if exists.
1566 If not exists, both the return value is nullptr and length is 0.
1567 @param[in] nth nth field to get
1568 @param[in,out] length length of the default value
1569 @return the default value data of nth field */
1570 const byte *get_nth_default(ulint nth, ulint *length) const {
1571 ut_ad(nth < get_n_total_fields());
1572
1573 const dict_col_t *col = get_physical_field(nth)->col;
1574 if (col->instant_default == nullptr) {
1575 *length = 0;
1576 return (nullptr);
1577 }
1578
1579 *length = col->instant_default->len;
1580 ut_ad(*length == 0 || *length == UNIV_SQL_NULL ||
1581 col->instant_default->value != nullptr);
1582 return (col->instant_default->value);
1583 }
1584
1585 /** Sets srid and srid_is_valid values
1586 @param[in] srid_value value of SRID, may be garbage
1587 if srid_is_valid_value = false
1588 @param[in] srid_is_valid_value value of srid_is_valid */
1589 void fill_srid_value(uint32_t srid_value, bool srid_is_valid_value) {
1590 srid_is_valid = srid_is_valid_value;
1591 srid = srid_value;
1592 }
1593
1594 /** Check if the underlying table is compressed.
1595 @return true if compressed, false otherwise. */
1596 inline bool is_compressed() const;
1597
1598 /** Check if a multi-value index is built on specified multi-value
1599 virtual column. Please note that there could be only one multi-value
1600 virtual column on the multi-value index, but not necessary the first
1601 field of the index.
1602 @param[in] mv_col multi-value virtual column
1603 @return non-zero means the column is on the index and this is the
1604 nth position of the column, zero means it's not on the index */
1605 uint32_t has_multi_value_col(const dict_v_col_t *mv_col) const {
1607 for (uint32_t i = 0; i < n_fields; ++i) {
1608 const dict_col_t *col = get_col(i);
1609 if (mv_col->m_col.ind == col->ind) {
1610 return (i + 1);
1611 }
1612
1613 /* Only one multi-value field, if not match then no match. */
1614 if (col->is_multi_value()) {
1615 break;
1616 }
1617 }
1618
1619 return (0);
1620 }
1621
1622 public:
1623 /** Get the page size of the tablespace to which this index belongs.
1624 @return the page size. */
1625 page_size_t get_page_size() const;
1626
1627 /** Get the space id of the tablespace to which this index belongs.
1628 @return the space id. */
1629 space_id_t space_id() const { return space; }
1630};
1631
1632/** The status of online index creation */
1634 /** the index is complete and ready for access */
1636 /** the index is being created, online
1637 (allowing concurrent modifications) */
1639 /** secondary index creation was aborted and the index
1640 should be dropped as soon as index->table->n_ref_count reaches 0,
1641 or online table rebuild was aborted and the clustered index
1642 of the original table should soon be restored to
1643 ONLINE_INDEX_COMPLETE */
1645 /** the online index creation was aborted, the index was
1646 dropped from the data dictionary and the tablespace, and it
1647 should be dropped from the data dictionary cache as soon as
1648 index->table->n_ref_count reaches 0. */
1651
1652/** Set to store the virtual columns which are affected by Foreign
1653key constraint. */
1654typedef std::set<dict_v_col_t *, std::less<dict_v_col_t *>,
1657
1658/** Data structure for a foreign key constraint; an example:
1659FOREIGN KEY (A, B) REFERENCES TABLE2 (C, D). Most fields will be
1660initialized to 0, NULL or false in dict_mem_foreign_create(). */
1662 mem_heap_t *heap; /*!< this object is allocated from
1663 this memory heap */
1664 char *id; /*!< id of the constraint as a
1665 null-terminated string */
1666 unsigned n_fields : 10; /*!< number of indexes' first fields
1667 for which the foreign key
1668 constraint is defined: we allow the
1669 indexes to contain more fields than
1670 mentioned in the constraint, as long
1671 as the first fields are as mentioned */
1672 unsigned type : 6; /*!< 0 or DICT_FOREIGN_ON_DELETE_CASCADE
1673 or DICT_FOREIGN_ON_DELETE_SET_NULL */
1674 char *foreign_table_name; /*!< foreign table name */
1676 /*!< foreign table name used for dict lookup */
1677 dict_table_t *foreign_table; /*!< table where the foreign key is */
1678 const char **foreign_col_names; /*!< names of the columns in the
1679 foreign key */
1680 char *referenced_table_name; /*!< referenced table name */
1682 /*!< referenced table name for dict lookup*/
1683 dict_table_t *referenced_table; /*!< table where the referenced key
1684 is */
1685 const char **referenced_col_names; /*!< names of the referenced
1686 columns in the referenced table */
1687 dict_index_t *foreign_index; /*!< foreign index; we require that
1688 both tables contain explicitly defined
1689 indexes for the constraint: InnoDB
1690 does not generate new indexes
1691 implicitly */
1692 dict_index_t *referenced_index; /*!< referenced index */
1693
1694 dict_vcol_set *v_cols; /*!< set of virtual columns affected
1695 by foreign key constraint. */
1696
1697 /** Check whether foreign key constraint contains a column with a full
1698 index on it. The function is used in the context of cascading DML
1699 operations.
1700 @retval true if the column has FTS index on it.
1701 @retval false if the FK table has no FTS index or has self referential
1702 relationship
1703 */
1704 bool is_fts_col_affected() const;
1705};
1706
1707std::ostream &operator<<(std::ostream &out, const dict_foreign_t &foreign);
1708
1710 dict_foreign_print(std::ostream &out) : m_out(out) {}
1711
1712 void operator()(const dict_foreign_t *foreign) { m_out << *foreign; }
1713
1714 private:
1715 std::ostream &m_out;
1716};
1717
1718/** Compare two dict_foreign_t objects using their ids. Used in the ordering
1719of dict_table_t::foreign_set and dict_table_t::referenced_set. It returns
1720true if the first argument is considered to go before the second in the
1721strict weak ordering it defines, and false otherwise. */
1723 bool operator()(const dict_foreign_t *lhs, const dict_foreign_t *rhs) const {
1724 return (ut_strcmp(lhs->id, rhs->id) < 0);
1725 }
1726};
1727
1728/** A function object to find a foreign key with the given index as the
1729referenced index. Return the foreign key with matching criteria or NULL */
1732
1733 bool operator()(const dict_foreign_t *foreign) const {
1734 return (foreign->referenced_index == m_index);
1735 }
1736
1738};
1739
1740/* A function object to check if the foreign constraint is between different
1741tables. Returns true if foreign key constraint is between different tables,
1742false otherwise. */
1744 bool operator()(const dict_foreign_t *foreign) const {
1745 return (foreign->foreign_table != foreign->referenced_table);
1746 }
1747};
1748
1752
1753std::ostream &operator<<(std::ostream &out, const dict_foreign_set &fk_set);
1754
1755/** Function object to check if a foreign key object is there
1756in the given foreign key set or not. It returns true if the
1757foreign key is not found, false otherwise */
1760
1761 /* Return true if the given foreign key is not found */
1762 bool operator()(dict_foreign_t *const &foreign) const {
1763 return (m_foreigns.find(foreign) == m_foreigns.end());
1764 }
1765
1766 private:
1768};
1769
1770/** Validate the search order in the foreign key set.
1771@param[in] fk_set the foreign key set to be validated
1772@return true if search order is fine in the set, false otherwise. */
1774
1775/** Validate the search order in the foreign key sets of the table
1776(foreign_set and referenced_set).
1777@param[in] table table whose foreign key sets are to be validated
1778@return true if foreign key sets are fine, false otherwise. */
1780
1781/** Frees a foreign key struct. */
1783 dict_foreign_t *foreign) /*!< in, own: foreign key struct */
1784{
1785 if (foreign->v_cols != nullptr) {
1786 ut::delete_(foreign->v_cols);
1787 }
1788
1789 mem_heap_free(foreign->heap);
1790}
1791
1792/** The destructor will free all the foreign key constraints in the set
1793by calling dict_foreign_free() on each of the foreign key constraints.
1794This is used to free the allocated memory when a local set goes out
1795of scope. */
1798 : m_foreign_set(foreign_set) {}
1799
1803 }
1804
1806};
1807
1808/** The flags for ON_UPDATE and ON_DELETE can be ORed; the default is that
1809a foreign key constraint is enforced, therefore RESTRICT just means no flag */
1810/** @{ */
1811/** ON DELETE CASCADE */
1812constexpr uint32_t DICT_FOREIGN_ON_DELETE_CASCADE = 1;
1813/** ON DELETE SET NULL */
1814constexpr uint32_t DICT_FOREIGN_ON_DELETE_SET_NULL = 2;
1815/** ON UPDATE CASCADE */
1816constexpr uint32_t DICT_FOREIGN_ON_UPDATE_CASCADE = 4;
1817/** ON UPDATE SET NULL */
1818constexpr uint32_t DICT_FOREIGN_ON_UPDATE_SET_NULL = 8;
1819/** ON DELETE NO ACTION */
1820constexpr uint32_t DICT_FOREIGN_ON_DELETE_NO_ACTION = 16;
1821/** ON UPDATE NO ACTION */
1822constexpr uint32_t DICT_FOREIGN_ON_UPDATE_NO_ACTION = 32;
1823/** @} */
1824
1825/** Display an identifier.
1826@param[in,out] s output stream
1827@param[in] id_name SQL identifier (other than table name)
1828@return the output stream */
1829std::ostream &operator<<(std::ostream &s, const id_name_t &id_name);
1830
1831/** Display a table name.
1832@param[in,out] s output stream
1833@param[in] table_name table name
1834@return the output stream */
1835std::ostream &operator<<(std::ostream &s, const table_name_t &table_name);
1836
1837#ifndef UNIV_HOTBACKUP
1838/** List of locks that different transactions have acquired on a table. This
1839list has a list node that is embedded in a nested union/structure. We have to
1840generate a specific template for it. */
1841struct TableLockGetNode;
1843#endif /* !UNIV_HOTBACKUP */
1844
1845/** mysql template structure defined in row0mysql.cc */
1846struct mysql_row_templ_t;
1847
1848/** Structure defines template related to virtual columns and
1849their base columns */
1851 /** number of regular columns */
1853
1854 /** number of virtual columns */
1856
1857 /** array of templates for virtual col and their base columns */
1859
1860 /** table's database name */
1861 std::string db_name;
1862
1863 /** table name */
1864 std::string tb_name;
1865
1866 /** share->table_name */
1867 std::string share_name;
1868
1869 /** MySQL record length */
1871
1872 /** default column value if any */
1874};
1875
1876/** The dirty status of tables, used to indicate if a table has some
1877dynamic metadata changed to be written back */
1879 /** Some persistent metadata is now dirty in memory, need to be
1880 written back to DDTableBuffer table and(or directly to) DD table.
1881 There could be some exceptions, when it's marked as dirty, but
1882 the metadata has already been written back to DDTableBuffer.
1883 For example, if a corrupted index is found and marked as corrupted,
1884 then it gets dropped. At this time, the dirty_status is still of
1885 this dirty value. Also a concurrent checkpoint make this bit
1886 out-of-date for other working threads, which still think the
1887 status is dirty and write-back is necessary.
1888 There could be either one row or no row for this table in
1889 DDTableBuffer table */
1891 /** Some persistent metadata is buffered in DDTableBuffer table,
1892 need to be written back to DD table. There is must be one row in
1893 DDTableBuffer table for this table */
1895 /** All persistent metadata are up to date. There is no row
1896 for this table in DDTableBuffer table */
1899
1900#ifndef UNIV_HOTBACKUP
1901/** A vector to collect prebuilt from different readers working on the same
1902temp table */
1903typedef std::vector<row_prebuilt_t *> temp_prebuilt_vec;
1904#endif /* !UNIV_HOTBACKUP */
1905
1906#ifdef UNIV_DEBUG
1907/** Value of 'magic_n'. */
1908constexpr uint32_t DICT_TABLE_MAGIC_N = 76333786;
1909#endif
1910
1911/** Data structure for a database table. Most fields will be
1912initialized to 0, NULL or false in dict_mem_table_create(). */
1914 /** Check if the table is compressed.
1915 @return true if compressed, false otherwise. */
1916 bool is_compressed() const { return (DICT_TF_GET_ZIP_SSIZE(flags) != 0); }
1917
1918 /** Check if the table is encrypted. Only for file per table tablespace.
1919 @return true if encrypted, false otherwise. */
1920 bool is_encrypted() const {
1922 }
1923
1924 /** Get reference count.
1925 @return current value of n_ref_count */
1926 inline uint64_t get_ref_count() const;
1927
1928 /** Acquire the table handle. */
1929 inline void acquire();
1930
1931 /** Acquire the table handle, with lock() and unlock() the table.
1932 This function needs to be called for opening table when the table
1933 is in memory and later the stats information would be initialized */
1934 inline void acquire_with_lock();
1935
1936 /** Release the table handle. */
1937 inline void release();
1938
1939 /** Lock the table handle. */
1940 inline void lock();
1941
1942 /** Unlock the table handle. */
1943 inline void unlock();
1944
1945#ifndef UNIV_HOTBACKUP
1946 /** Get schema and table name in system character set.
1947 @param[out] schema schema name
1948 @param[out] table table name */
1949 void get_table_name(std::string &schema, std::string &table) const;
1950
1951 bool is_system_schema() const {
1952 std::string schema_name;
1953 std::string table_name;
1954
1955 get_table_name(schema_name, table_name);
1956
1957 if (0 == strcmp(schema_name.c_str(), MYSQL_SCHEMA_NAME.str) ||
1958 0 == strcmp(schema_name.c_str(), "sys") ||
1959 0 == strcmp(schema_name.c_str(), PERFORMANCE_SCHEMA_DB_NAME.str) ||
1960 0 == strcmp(schema_name.c_str(), INFORMATION_SCHEMA_NAME.str)) {
1961 return (true);
1962 }
1963 return (false);
1964 }
1965
1966 /** Mutex of the table for concurrency access. */
1967 ib_mutex_t *mutex;
1968
1969 /** Creation state of mutex. */
1970 std::atomic<os_once::state_t> mutex_created;
1971#endif /* !UNIV_HOTBACKUP */
1972
1973 /** Id of the table. */
1975
1976 /** Memory heap. If you allocate from this heap after the table has
1977 been created then be sure to account the allocation into
1978 dict_sys->size. When closing the table we do something like
1979 dict_sys->size -= mem_heap_get_size(table->heap) and if that is going
1980 to become negative then we would assert. Something like this should do:
1981 old_size = mem_heap_get_size()
1982 mem_heap_alloc()
1983 new_size = mem_heap_get_size()
1984 dict_sys->size += new_size - old_size. */
1986
1987 /** Table name. */
1989
1990 /** Truncate name. */
1992
1993 /** NULL or the directory path specified by DATA DIRECTORY. */
1995
1996 /** NULL or the tablespace name that this table is assigned to,
1997 specified by the TABLESPACE option.*/
1999
2000 /** Space where the clustered index of the table is placed. */
2002
2003 /** dd::Tablespace::id of the table */
2005
2006 /** Stores information about:
2007 1 row format (redundant or compact),
2008 2 compressed page size (zip shift size),
2009 3 whether using atomic blobs,
2010 4 whether the table has been created with the option DATA DIRECTORY.
2011 Use DICT_TF_GET_COMPACT(), DICT_TF_GET_ZIP_SSIZE(),
2012 DICT_TF_HAS_ATOMIC_BLOBS() and DICT_TF_HAS_DATA_DIR() to parse this
2013 flag. */
2015
2016 /** Stores information about:
2017 1 whether the table has been created using CREATE TEMPORARY TABLE,
2018 2 whether the table has an internally defined DOC ID column,
2019 3 whether the table has a FTS index,
2020 4 whether DOC ID column need to be added to the FTS index,
2021 5 whether the table is being created its own tablespace,
2022 6 whether the table has been DISCARDed,
2023 7 whether the aux FTS tables names are in hex.
2024 8 whether the table is instinc table.
2025 9 whether the table has encryption setting.
2026 Use DICT_TF2_FLAG_IS_SET() to parse this flag. */
2028
2029 /** true if the table is an intermediate table during copy alter
2030 operation or a partition/subpartition which is required for copying
2031 data and skip the undo log for insertion of row in the table.
2032 This variable will be set and unset during extra(), or during the
2033 process of altering partitions */
2034 unsigned skip_alter_undo : 1;
2035
2036 /** true if this is in a single-table tablespace and the .ibd file is
2037 missing. Then we must return in ha_innodb.cc an error if the user
2038 tries to query such an orphaned table. */
2039 unsigned ibd_file_missing : 1;
2040
2041 /** true if the table object has been added to the dictionary cache. */
2042 unsigned cached : 1;
2043
2044 /** true if the table is to be dropped, but not yet actually dropped
2045 (could in the background drop list). It is turned on at the beginning
2046 of row_drop_table_for_mysql() and turned off just before we start to
2047 update system tables for the drop. It is protected by
2048 dict_operation_lock. */
2049 unsigned to_be_dropped : 1;
2050
2051 /** Number of non-virtual columns defined so far. */
2052 unsigned n_def : 10;
2053
2054 /** Number of non-virtual columns. */
2055 unsigned n_cols : 10;
2056
2057 /** Number of non-virtual columns before first instant ADD COLUMN,
2058 including the system columns like n_cols. This is used only when table has
2059 instant ADD clumns in V1. */
2060 unsigned n_instant_cols : 10;
2061
2062 /** Number of total columns (include virtual and non-virtual) */
2063 unsigned n_t_cols : 10;
2064
2065 /** Number of total columns defined so far. */
2066 unsigned n_t_def : 10;
2067
2068 /** Number of virtual columns defined so far. */
2069 unsigned n_v_def : 10;
2070
2071 /** Number of virtual columns. */
2072 unsigned n_v_cols : 10;
2073
2074 /** Number of multi-value virtual columns. */
2075 unsigned n_m_v_cols : 10;
2076
2077 /** true if this table is expected to be kept in memory. This table
2078 could be a table that has FK relationships or is undergoing DDL */
2080
2081 /** true if this table is not evictable(can_be_evicted) and this is
2082 because of DDL operation */
2083 unsigned ddl_not_evictable : 1;
2084
2085 /** true if some indexes should be dropped after ONLINE_INDEX_ABORTED
2086 or ONLINE_INDEX_ABORTED_DROPPED. */
2087 unsigned drop_aborted : 1;
2088
2089 /** Array of column descriptions. */
2091
2092 /** Array of virtual column descriptions. */
2094
2095 /** List of stored column descriptions. It is used only for foreign key
2096 check during create table and copy alter operations.
2097 During copy alter, s_cols list is filled during create table operation
2098 and need to preserve till rename table operation. That is the
2099 reason s_cols is a part of dict_table_t */
2101
2102 /** Column names packed in a character string
2103 "name1\0name2\0...nameN\0". Until the string contains n_cols, it will
2104 be allocated from a temporary heap. The final string will be allocated
2105 from table->heap. */
2106 const char *col_names;
2107
2108 /** Virtual column names */
2109 const char *v_col_names;
2110
2111 /** True if the table belongs to a system database (mysql, information_schema
2112 or performance_schema) */
2114
2115 /** Hash chain node. */
2117
2118 /** Hash chain node. */
2120
2121 /** The FTS_DOC_ID_INDEX, or NULL if no fulltext indexes exist */
2123
2124 /** List of indexes of the table. */
2126
2127 size_t get_index_count() const { return UT_LIST_GET_LEN(indexes); }
2128
2129 /** Node of the LRU list of tables. */
2131
2132 /** metadata version number of dd::Table::se_private_data() */
2133 uint64_t version;
2134
2135 /** Current row version in case columns are added/dropped INSTANTly */
2137
2138 /** Initial non-virtual column count */
2140
2141 /** Current non-virtual column count */
2143
2144 /** Total non-virtual column count */
2145 uint32_t total_col_count{0};
2146
2147 /** Set if table is upgraded instant table */
2149
2150 /** table dynamic metadata status, protected by dict_persist->mutex */
2151 std::atomic<table_dirty_status> dirty_status;
2152
2153#ifndef UNIV_HOTBACKUP
2154 /** Node of the dirty table list of tables, which is protected
2155 by dict_persist->mutex */
2156 UT_LIST_NODE_T(dict_table_t) dirty_dict_tables;
2157#endif /* !UNIV_HOTBACKUP */
2158
2159#ifdef UNIV_DEBUG
2160 /** This field is used to mark if a table is in the
2161 dirty_dict_tables_list. if the dirty_status is not of
2162 METADATA_CLEAN, the table should be in the list, otherwise not.
2163 This field should be protected by dict_persist->mutex too. */
2165#endif /* UNIV_DEBUG */
2166
2167 /** Maximum recursive level we support when loading tables chained
2168 together with FK constraints. If exceeds this level, we will stop
2169 loading child table into memory along with its parent table. */
2171
2172 /** Count of how many foreign key check operations are currently being
2173 performed on the table. We cannot drop the table while there are
2174 foreign key checks running on it. */
2176
2177 /** Transaction id that last touched the table definition. Either when
2178 loading the definition or CREATE TABLE, or ALTER TABLE (prepare,
2179 commit, and rollback phases). */
2181
2182 /*!< set of foreign key constraints in the table; these refer to
2183 columns in other tables */
2185
2186 /*!< set of foreign key constraints which refer to this table */
2188
2189#ifdef UNIV_DEBUG
2190 /** This field is used to specify in simulations tables which are so
2191 big that disk should be accessed. Disk access is simulated by putting
2192 the thread to sleep for a while. NOTE that this flag is not stored to
2193 the data dictionary on disk, and the database will forget about value
2194 true if it has to reload the table definition from disk. */
2196#endif /* UNIV_DEBUG */
2197
2198 /** true if the maximum length of a single row exceeds BIG_ROW_SIZE.
2199 Initialized in dict_table_add_to_cache(). */
2200 unsigned big_rows : 1;
2201
2202#ifndef UNIV_HOTBACKUP
2203 /** Statistics for query optimization. @{ */
2204
2205 /** Creation state of 'stats_latch'. */
2206 std::atomic<os_once::state_t> stats_latch_created;
2207
2208 /** This latch protects:
2209 "dict_table_t::stat_initialized",
2210 "dict_table_t::stat_n_rows (*)",
2211 "dict_table_t::stat_clustered_index_size",
2212 "dict_table_t::stat_sum_of_other_index_sizes",
2213 "dict_table_t::stat_modified_counter (*)",
2214 "dict_table_t::indexes*::stat_n_diff_key_vals[]",
2215 "dict_table_t::indexes*::stat_index_size",
2216 "dict_table_t::indexes*::stat_n_leaf_pages".
2217 (*) Those are not always protected for
2218 performance reasons. */
2220
2221 /** true if statistics have been calculated the first time after
2222 database startup or table creation. */
2223 unsigned stat_initialized : 1;
2224
2225 /** Timestamp of last recalc of the stats. */
2226 std::chrono::steady_clock::time_point stats_last_recalc;
2227
2228/** The two bits below are set in the 'stat_persistent' member. They
2229have the following meaning:
22301. _ON=0, _OFF=0, no explicit persistent stats setting for this table,
2231the value of the global srv_stats_persistent is used to determine
2232whether the table has persistent stats enabled or not
22332. _ON=0, _OFF=1, persistent stats are explicitly disabled for this
2234table, regardless of the value of the global srv_stats_persistent
22353. _ON=1, _OFF=0, persistent stats are explicitly enabled for this
2236table, regardless of the value of the global srv_stats_persistent
22374. _ON=1, _OFF=1, not allowed, we assert if this ever happens. */
2238#define DICT_STATS_PERSISTENT_ON (1 << 1)
2239#define DICT_STATS_PERSISTENT_OFF (1 << 2)
2240
2241 /** Indicates whether the table uses persistent stats or not. See
2242 DICT_STATS_PERSISTENT_ON and DICT_STATS_PERSISTENT_OFF. */
2244
2245/** The two bits below are set in the 'stats_auto_recalc' member. They
2246have the following meaning:
22471. _ON=0, _OFF=0, no explicit auto recalc setting for this table, the
2248value of the global srv_stats_persistent_auto_recalc is used to
2249determine whether the table has auto recalc enabled or not
22502. _ON=0, _OFF=1, auto recalc is explicitly disabled for this table,
2251regardless of the value of the global srv_stats_persistent_auto_recalc
22523. _ON=1, _OFF=0, auto recalc is explicitly enabled for this table,
2253regardless of the value of the global srv_stats_persistent_auto_recalc
22544. _ON=1, _OFF=1, not allowed, we assert if this ever happens. */
2255#define DICT_STATS_AUTO_RECALC_ON (1 << 1)
2256#define DICT_STATS_AUTO_RECALC_OFF (1 << 2)
2257
2258 /** Indicates whether the table uses automatic recalc for persistent
2259 stats or not. See DICT_STATS_AUTO_RECALC_ON and
2260 DICT_STATS_AUTO_RECALC_OFF. */
2262
2263 /** The number of pages to sample for this table during persistent
2264 stats estimation. If this is 0, then the value of the global
2265 srv_stats_persistent_sample_pages will be used instead. */
2267
2268 /** Approximate number of rows in the table. We periodically calculate
2269 new estimates. */
2270 uint64_t stat_n_rows;
2271
2272 /** Approximate clustered index size in database pages. */
2274
2275 /** Approximate size of other indexes in database pages. */
2277
2278 /** If FTS AUX table, parent table id */
2280
2281 /** How many rows are modified since last stats recalc. When a row is
2282 inserted, updated, or deleted, we add 1 to this number; we calculate
2283 new estimates for the table and the indexes if the table has changed
2284 too much, see row_update_statistics_if_needed(). The counter is reset
2285 to zero at statistics calculation. This counter is not protected by
2286 any latch, because this is only used for heuristics. */
2288
2289/** Background stats thread is not working on this table. */
2290#define BG_STAT_NONE 0
2291
2292/** Set in 'stats_bg_flag' when the background stats code is working
2293on this table. The DROP TABLE code waits for this to be cleared before
2294proceeding. */
2295#define BG_STAT_IN_PROGRESS (1 << 0)
2296
2297/** Set in 'stats_bg_flag' when DROP TABLE starts waiting on
2298BG_STAT_IN_PROGRESS to be cleared. The background stats thread will
2299detect this and will eventually quit sooner. */
2300#define BG_STAT_SHOULD_QUIT (1 << 1)
2301
2302 /** The state of the background stats thread wrt this table.
2303 See BG_STAT_NONE, BG_STAT_IN_PROGRESS and BG_STAT_SHOULD_QUIT.
2304 Writes are covered by dict_sys->mutex. Dirty reads are possible. */
2306
2307 /** @} */
2308#endif /* !UNIV_HOTBACKUP */
2309
2310 /** AUTOINC related members. @{ */
2311
2312 /* The actual collection of tables locked during AUTOINC read/write is
2313 kept in trx_t. In order to quickly determine whether a transaction has
2314 locked the AUTOINC lock we keep a pointer to the transaction here in
2315 the 'autoinc_trx' member. This is to avoid acquiring lock_sys latches and
2316 scanning the vector in trx_t.
2317 When an AUTOINC lock has to wait, the corresponding lock instance is
2318 created on the trx lock heap rather than use the pre-allocated instance
2319 in autoinc_lock below. */
2320
2321 /** A buffer for an AUTOINC lock for this table. We allocate the
2322 memory here so that individual transactions can get it and release it
2323 without a need to allocate space from the lock heap of the trx:
2324 otherwise the lock heap would grow rapidly if we do a large insert
2325 from a select. */
2326#ifndef UNIV_HOTBACKUP
2328
2329 /** Creation state of autoinc_mutex member */
2330 std::atomic<os_once::state_t> autoinc_mutex_created;
2331#endif /* !UNIV_HOTBACKUP */
2332
2333 /** Mutex protecting the autoincrement counter. */
2334 ib_mutex_t *autoinc_mutex;
2335
2336 /** Autoinc counter value to give to the next inserted row. */
2337 uint64_t autoinc;
2338
2339 /** Mutex protecting the persisted autoincrement counter. */
2341
2342 /** Autoinc counter value that has been persisted in redo logs or
2343 DDTableBuffer. It's mainly used when we want to write counter back
2344 to DDTableBuffer.
2345 This is different from the 'autoinc' above, which could be bigger
2346 than this one, because 'autoinc' will get updated right after
2347 some counters are allocated, but we will write the counter to redo
2348 logs and update this counter later. Once all allocated counters
2349 have been written to redo logs, 'autoinc' should be exact the next
2350 counter of this persisted one.
2351 We want this counter because when we need to write the counter back
2352 to DDTableBuffer, we had better keep it consistency with the counter
2353 that has been written to redo logs. Besides, we can't read the 'autoinc'
2354 directly easily, because the autoinc_lock is required and there could
2355 be a deadlock.
2356 This variable is protected by autoinc_persisted_mutex. */
2358
2359 /** The position of autoinc counter field in clustered index. This would
2360 be set when CREATE/ALTER/OPEN TABLE and IMPORT TABLESPACE, and used in
2361 modifications to clustered index, such as INSERT/UPDATE. There should
2362 be no conflict to access it, so no protection is needed. */
2364
2365 /** The transaction that currently holds the the AUTOINC lock on this table.
2366 Protected by lock_sys table shard latch. To "peek" the current value one
2367 can read it without any latch, understanding that in general it may change.
2368 Such access pattern is correct if trx thread wants to check if it has the lock
2369 granted, as the field can only change to other value when lock is released,
2370 which can not happen concurrently to thread executing the trx. */
2371 std::atomic<const trx_t *> autoinc_trx;
2372
2373 /** @} */
2374
2375#ifndef UNIV_HOTBACKUP
2376 /** FTS specific state variables. */
2378#endif /* !UNIV_HOTBACKUP */
2379
2380 /** Quiescing states, protected by the dict_index_t::lock. ie. we can
2381 only change the state if we acquire all the latches (dict_index_t::lock)
2382 in X mode of this table's indexes. */
2384
2385 /** Count of the number of record locks on this table. We use this to
2386 determine whether we can evict the table from the dictionary cache.
2387 Writes (atomic increments and decrements) are performed when holding a shared
2388 latch on lock_sys. (Note that this the table's shard latch is NOT required,
2389 as this is field counts *record* locks, so a page shard is latched instead)
2390 Reads should be performed when holding exclusive lock_sys latch, however:
2391 - Some places assert this field is zero without holding any latch.
2392 - Some places assert this field is positive holding only shared latch. */
2393 std::atomic<size_t> n_rec_locks;
2394
2395#ifndef UNIV_DEBUG
2396 private:
2397#endif
2398 /** Count of how many handles are opened to this table. Dropping of the
2399 table is NOT allowed until this count gets to zero. MySQL does NOT
2400 itself check the number of open handles at DROP. */
2401 std::atomic<uint64_t> n_ref_count;
2402
2403 public:
2404#ifndef UNIV_HOTBACKUP
2405 /** List of locks on the table. Protected by lock_sys shard latch. */
2407 /** count_by_mode[M] = number of locks in this->locks with
2408 lock->type_mode&LOCK_MODE_MASK == M.
2409 Used to quickly verify that there are no LOCK_S or LOCK_X, which are the only
2410 modes incompatible with LOCK_IS and LOCK_IX, to avoid costly iteration over
2411 this->locks when adding LOCK_IS or LOCK_IX.
2412 We use count_by_mode[LOCK_AUTO_INC] to track the number of granted and pending
2413 autoinc locks on this table. This value is set after acquiring the lock_sys
2414 table shard latch, but we peek the contents to determine whether other
2415 transactions have acquired the AUTOINC lock or not. Of course only one
2416 transaction can be granted the lock but there can be multiple
2417 waiters.
2418 Protected by lock_sys table shard latch. */
2420#endif /* !UNIV_HOTBACKUP */
2421
2422 /** Timestamp of the last modification of this table. */
2423 std::atomic<std::chrono::system_clock::time_point> update_time;
2424 static_assert(decltype(update_time)::is_always_lock_free);
2425
2426 /** row-id counter for use by intrinsic table for getting row-id.
2427 Given intrinsic table semantics, row-id can be locally maintained
2428 instead of getting it from central generator which involves mutex
2429 locking. */
2430 uint64_t sess_row_id;
2431
2432 /** trx_id counter for use by intrinsic table for getting trx-id.
2433 Intrinsic table are not shared so don't need a central trx-id
2434 but just need a increased counter to track consistent view while
2435 proceeding SELECT as part of UPDATE. */
2436 uint64_t sess_trx_id;
2437
2438#ifdef UNIV_DEBUG
2439 /** Magic number. */
2441#endif /* UNIV_DEBUG */
2442 /** mysql_row_templ_t for base columns used for compute the virtual
2443 columns */
2445
2446 /** remove the dict_table_t from cache after DDL operation */
2448
2449 /** refresh/reload FK info */
2451
2452#ifndef UNIV_HOTBACKUP
2453 /** multiple cursors can be active on this temporary table */
2455#endif /* !UNIV_HOTBACKUP */
2456
2457 /** true only for dictionary tables like mysql/tables,
2458 mysql/columns, mysql/tablespaces, etc. This flag is used
2459 to do non-locking reads on DD tables. */
2461
2462 /** true if this table is explicitly put to non-LRU list
2463 during table creation */
2465
2466 /** Check if the table has user defined primary key (PK).
2467 @return true if table has user defined PK, false otherwise. */
2468 bool has_pk() const;
2469
2470 /** @return the clustered index */
2471 const dict_index_t *first_index() const {
2473 const dict_index_t *first = UT_LIST_GET_FIRST(indexes);
2474 return (first);
2475 }
2476 /** @return the clustered index */
2478 return (const_cast<dict_index_t *>(
2479 const_cast<const dict_table_t *>(this)->first_index()));
2480 }
2481
2482 /** @returns true if the table has row versions.. */
2483 bool has_row_versions() const {
2484 if (current_row_version > 0) {
2486 return (true);
2487 }
2488
2489 return false;
2490 }
2491
2492 /** @return if there was any instantly added column.
2493 This will be true after one or more instant ADD COLUMN, however,
2494 it would become false after ALTER TABLE which rebuilds or copies
2495 the old table.
2496 If this is true, all instantly added columns should have default
2497 values, and records in the table may have REC_INFO_INSTANT_FLAG set. */
2498 bool has_instant_cols() const {
2500 /* Instant add col V1 */
2501 return (true);
2502 }
2503
2504 return false;
2505 }
2506
2507 /** Set the number of columns when the first instant ADD COLUMN happens.
2508 @param[in] n_inst_cols number of fields when first instant
2509 ADD COLUMN happens, without system columns */
2510 void set_instant_cols(uint16_t n_inst_cols) {
2511 n_instant_cols = static_cast<unsigned>(n_inst_cols) + get_n_sys_cols();
2512 }
2513
2514 /** Get the number of user columns when the first instant ADD COLUMN
2515 happens.
2516 @return the number of user columns as described above */
2517 uint16_t get_instant_cols() const {
2518 return static_cast<uint16_t>(n_instant_cols - get_n_sys_cols());
2519 }
2520
2522 size_t n_cols_dropped = get_n_instant_drop_cols();
2523 size_t n_cols_added = get_n_instant_add_cols();
2524 size_t n_instant_added_cols =
2525 n_cols + n_cols_dropped - n_cols_added - n_instant_cols;
2526
2527 return (n_instant_added_cols);
2528 }
2529
2530 /** Get number of columns added instantly */
2531 uint32_t get_n_instant_add_cols() const {
2534 }
2535
2536 /** Get number of columns dropped instantly */
2537 uint32_t get_n_instant_drop_cols() const {
2540 }
2541
2542 /** check if table has INSTANT ADD columns.
2543 @return true if the table has INSTANT ADD columns, otherwise false */
2544 bool has_instant_add_cols() const { return (get_n_instant_add_cols() > 0); }
2545
2546 /** check if table has INSTANT DROP columns.
2547 @return true if the table has INSTANT DROP columns, otherwise false */
2548 bool has_instant_drop_cols() const { return (get_n_instant_drop_cols() > 0); }
2549
2550 /** Set table to be upgraded table with INSTANT ADD columns in V1. */
2552
2553 /** Checks if table is upgraded table with INSTANT ADD columns in V1.
2554 @return true if it is, false otherwise */
2556
2557 /** Check whether the table is corrupted.
2558 @return true if the table is corrupted, otherwise false */
2559 bool is_corrupted() const {
2561
2562 const dict_index_t *index = first_index();
2563
2564 /* It is possible that this table is only half created, in which case
2565 the clustered index may be NULL. If the clustered index is corrupted,
2566 the table is corrupt. We do not consider the table corrupt if only
2567 a secondary index is corrupt. */
2568 ut_ad(index == nullptr || index->is_clustered());
2569
2570 return (index != nullptr && index->type & DICT_CORRUPT);
2571 }
2572
2573 /** Returns a column's name.
2574 @param[in] col_nr column number
2575 @return column name. NOTE: not guaranteed to stay valid if table is
2576 modified in any way (columns added, etc.). */
2577 const char *get_col_name(ulint col_nr) const {
2578 ut_ad(col_nr < n_def);
2580
2581 const char *s = col_names;
2582 if (s) {
2583 for (ulint i = 0; i < col_nr; i++) {
2584 s += strlen(s) + 1;
2585 }
2586 }
2587
2588 return (s);
2589 }
2590
2591 /** Gets the nth column of a table.
2592 @param[in] pos position of column
2593 @return pointer to column object */
2594 dict_col_t *get_col(uint pos) const {
2595 ut_ad(pos < n_def);
2597
2598 return (cols + pos);
2599 }
2600
2601 /** Get column by name
2602 @param[in] name column name
2603 @return column name if found, null otherwise */
2604 dict_col_t *get_col_by_name(const char *name) const {
2605 ut_ad(name != nullptr);
2606
2607 dict_col_t *ret = nullptr;
2608
2609 const char *s = col_names;
2610 for (ulint i = 0; i < n_def; i++) {
2611 if (strcmp(s, name) == 0) {
2612 ret = get_col(i);
2613 }
2614 s += strlen(s) + 1;
2615 }
2616
2617 return ret;
2618 }
2619
2620 /** Gets the number of user-defined non-virtual columns in a table
2621 in the dictionary cache.
2622 @return number of user-defined (e.g., not ROW_ID) non-virtual columns
2623 of a table */
2624 uint16_t get_n_user_cols() const {
2626
2627 return (static_cast<uint16_t>(n_cols) - get_n_sys_cols());
2628 }
2629
2630 /** Gets the number of system columns in a table.
2631 For intrinsic table on ROW_ID column is added for all other
2632 tables TRX_ID and ROLL_PTR are all also appended.
2633 @return number of system (e.g., ROW_ID) columns of a table */
2634 uint16_t get_n_sys_cols() const {
2636
2638 }
2639
2640 /** Gets the number of all non-virtual columns (also system) in a table
2641 in the dictionary cache.
2642 @return number of non-virtual columns of a table */
2645
2646 return (n_cols);
2647 }
2648
2649 /** Gets the number of all non-virtual columns in a table including columns
2650 dropped INSTANTly.
2651 @returns number of non-virtual columns of a table */
2653 if (!has_row_versions()) {
2654 return n_cols;
2655 }
2656
2660 }
2661
2662 /** Gets the given system column of a table.
2663 @param[in] sys DATA_ROW_ID, ...
2664 @return pointer to column object */
2666 dict_col_t *col;
2667
2668 ut_ad(sys < get_n_sys_cols());
2670
2671 col = get_col(n_cols - get_n_sys_cols() + sys);
2672 ut_ad(col->mtype == DATA_SYS);
2673 ut_ad(col->prtype == (sys | DATA_NOT_NULL));
2674
2675 return (col);
2676 }
2677
2678 /** Determine if this is a temporary table. */
2679 bool is_temporary() const {
2681 return (flags2 & DICT_TF2_TEMPORARY);
2682 }
2683
2684 /** Determine if this is a FTS AUX table. */
2685 bool is_fts_aux() const {
2687 return (flags2 & DICT_TF2_AUX);
2688 }
2689
2690 /** Determine whether the table is intrinsic.
2691 An intrinsic table is a special kind of temporary table that
2692 is invisible to the end user. It can be created internally by InnoDB,
2693 the MySQL server layer or other modules connected to InnoDB in order
2694 to gather and use data as part of a larger task. Since access to it
2695 must be as fast as possible, it does not need UNDO semantics, system
2696 fields DB_TRX_ID & DB_ROLL_PTR, doublewrite, checksum, insert buffer,
2697 use of the shared data dictionary, locking, or even a transaction.
2698 In short, these are not ACID tables at all, just temporary data stored
2699 and manipulated during a larger process.*/
2700 bool is_intrinsic() const {
2701 if (flags2 & DICT_TF2_INTRINSIC) {
2703 return (true);
2704 }
2705
2706 return (false);
2707 }
2708
2709 /* GAP locks are skipped for DD tables and SDI tables
2710 @return true if table is DD table or SDI table, else false */
2711 inline bool skip_gap_locks() const;
2712
2713 /** Determine if the table can support instant ADD/DROP COLUMN */
2714 inline bool support_instant_add_drop() const;
2715};
2716
2717static inline void DICT_TF2_FLAG_SET(dict_table_t *table, uint32_t flag) {
2718 table->flags2 |= flag;
2719}
2720
2721static inline bool DICT_TF2_FLAG_IS_SET(const dict_table_t *table,
2722 uint32_t flag) {
2723 return table->flags2 & flag;
2724}
2725
2726static inline void DICT_TF2_FLAG_UNSET(dict_table_t *table, uint32_t flag) {
2727 table->flags2 &= ~flag;
2728}
2729
2731
2732/** Persistent dynamic metadata type, there should be 1 to 1
2733relationship between the metadata and the type. Please keep them in order
2734so that we can iterate over it */
2736 /** The smallest type, which should be 1 less than the first
2737 true type */
2739
2740 /** Persistent Metadata type for corrupted indexes */
2742
2743 /** Persistent Metadata type for autoinc counter */
2745
2746 /* TODO: Will add following types
2747 PM_TABLE_UPDATE_TIME = 3,
2748 Maybe something tablespace related
2749 PM_TABLESPACE_SIZE = 4,
2750 PM_TABLESPACE_MAX_TRX_ID = 5, */
2751
2752 /** The biggest type, which should be 1 bigger than the last
2753 true type */
2754 PM_BIGGEST_TYPE = 3
2756
2757typedef std::vector<index_id_t, ut::allocator<index_id_t>> corrupted_ids_t;
2758
2759/** Persistent dynamic metadata for a table */
2761 public:
2762 /** Constructor
2763 @param[in] id table id
2764 @param[in] version table dynamic metadata version */
2767
2768 /** Get the corrupted indexes' IDs
2769 @return the vector of indexes' IDs */
2771 return (m_corrupted_ids);
2772 }
2773
2774 /** Add a corrupted index id and space id
2775 @param[in] id corrupted index id */
2777 m_corrupted_ids.push_back(id);
2778 }
2779
2780 /** Set the dynamic metadata version.
2781 @param[in] version dynamic metadata version */
2782 void set_version(uint64_t version) { m_version = version; }
2783
2784 /** Get the dynamic metadata version */
2785 uint64_t get_version() const { return (m_version); }
2786
2787 /** Get the table id of the metadata
2788 @return table id */
2789 table_id_t get_table_id() const { return (m_id); }
2790
2791 /** Set the autoinc counter of the table if it's bigger
2792 @param[in] autoinc autoinc counter */
2793 void set_autoinc_if_bigger(uint64_t autoinc) {
2794 /* We only set the biggest autoinc counter. Callers don't
2795 guarantee passing a bigger number in. */
2796 if (autoinc > m_autoinc) {
2797 m_autoinc = autoinc;
2798 }
2799 }
2800
2801 /** Set the autoinc counter of the table
2802 @param[in] autoinc autoinc counter */
2803 void set_autoinc(uint64_t autoinc) { m_autoinc = autoinc; }
2804
2805 /** Get the autoinc counter of the table
2806 @return the autoinc counter */
2807 uint64_t get_autoinc() const { return (m_autoinc); }
2808
2809 private:
2810 /** Table ID which this metadata belongs to */
2812
2813 /** Table dynamic metadata version of the change */
2814 uint64_t m_version;
2815
2816 /** Storing the corrupted indexes' ID if exist, or else empty */
2818
2819 /** Autoinc counter of the table */
2820 uint64_t m_autoinc;
2821
2822 /* TODO: We will add update_time, etc. here and APIs accordingly */
2823};
2824
2825/** Interface for persistent dynamic table metadata. */
2827 public:
2828 /** Virtual destructor */
2829 virtual ~Persister() = default;
2830
2831 /** Write the dynamic metadata of a table, we can pre-calculate
2832 the size by calling get_write_size()
2833 @param[in] metadata persistent data
2834 @param[out] buffer write buffer
2835 @param[in] size size of write buffer, should be
2836 at least get_write_size()
2837 @return the length of bytes written */
2838 virtual ulint write(const PersistentTableMetadata &metadata, byte *buffer,
2839 ulint size) const = 0;
2840
2841 /** Pre-calculate the size of metadata to be written
2842 @param[in] metadata metadata to be written
2843 @return the size of metadata */
2845 const PersistentTableMetadata &metadata) const = 0;
2846
2847 /** Read the dynamic metadata from buffer, and store them to
2848 metadata object
2849 @param[out] metadata metadata where we store the read data
2850 @param[in] buffer buffer to read
2851 @param[in] size size of buffer
2852 @param[out] corrupt true if we found something wrong in
2853 the buffer except incomplete buffer,
2854 otherwise false
2855 @return the bytes we read from the buffer if the buffer data
2856 is complete and we get everything, 0 if the buffer is incompleted */
2857 virtual ulint read(PersistentTableMetadata &metadata, const byte *buffer,
2858 ulint size, bool *corrupt) const = 0;
2859
2860 /** Aggregate metadata entries into a single metadata instance, considering
2861 version numbers
2862 @param[in,out] metadata metadata object to be modified
2863 @param[in] new_entry metadata entry from logs */
2864 virtual void aggregate(PersistentTableMetadata &metadata,
2865 const PersistentTableMetadata &new_entry) const = 0;
2866
2867 /** Write MLOG_TABLE_DYNAMIC_META for persistent dynamic
2868 metadata of table
2869 @param[in] id Table id
2870 @param[in] metadata Metadata used to write the log
2871 @param[in,out] mtr Mini-transaction */
2872 void write_log(table_id_t id, const PersistentTableMetadata &metadata,
2873 mtr_t *mtr) const;
2874};
2875
2876/** Persister used for corrupted indexes */
2878 public:
2879 /** Write the corrupted indexes of a table, we can pre-calculate the size
2880 by calling get_write_size()
2881 @param[in] metadata persistent data
2882 @param[out] buffer write buffer
2883 @param[in] size size of write buffer, should be at least
2884 get_write_size()
2885 @return the length of bytes written */
2886 ulint write(const PersistentTableMetadata &metadata, byte *buffer,
2887 ulint size) const override;
2888
2889 /** Pre-calculate the size of metadata to be written
2890 @param[in] metadata metadata to be written
2891 @return the size of metadata */
2892 ulint get_write_size(const PersistentTableMetadata &metadata) const override;
2893
2894 /** Read the corrupted indexes from buffer, and store them to
2895 metadata object
2896 @param[out] metadata metadata where we store the read data
2897 @param[in] buffer buffer to read
2898 @param[in] size size of buffer
2899 @param[out] corrupt true if we found something wrong in
2900 the buffer except incomplete buffer,
2901 otherwise false
2902 @return the bytes we read from the buffer if the buffer data
2903 is complete and we get everything, 0 if the buffer is incompleted */
2904 ulint read(PersistentTableMetadata &metadata, const byte *buffer, ulint size,
2905 bool *corrupt) const override;
2906
2907 void aggregate(PersistentTableMetadata &metadata,
2908 const PersistentTableMetadata &new_entry) const override;
2909
2910 private:
2911 /** The length of index_id_t we will write */
2912 static const size_t INDEX_ID_LENGTH = 12;
2913};
2914
2915/** Persister used for autoinc counters */
2917 public:
2918 /** Write the autoinc counter of a table, we can pre-calculate
2919 the size by calling get_write_size()
2920 @param[in] metadata persistent metadata
2921 @param[out] buffer write buffer
2922 @param[in] size size of write buffer, should be
2923 at least get_write_size()
2924 @return the length of bytes written */
2925 ulint write(const PersistentTableMetadata &metadata, byte *buffer,
2926 ulint size) const override;
2927
2928 /** Pre-calculate the size of metadata to be written
2929 @param[in] metadata metadata to be written
2930 @return the size of metadata */
2932 [[maybe_unused]]) const override {
2933 /* We just return the max possible size that would be used
2934 if the counter exists, so we don't calculate every time.
2935 Here we need 1 byte for dynamic metadata type and 11 bytes
2936 for the max possible size of counter. */
2937 return (12);
2938 }
2939
2940 /** Read the autoinc counter from buffer, and store them to
2941 metadata object
2942 @param[out] metadata metadata where we store the read data
2943 @param[in] buffer buffer to read
2944 @param[in] size size of buffer
2945 @param[out] corrupt true if we found something wrong in
2946 the buffer except incomplete buffer,
2947 otherwise false
2948 @return the bytes we read from the buffer if the buffer data
2949 is complete and we get everything, 0 if the buffer is incomplete */
2950 ulint read(PersistentTableMetadata &metadata, const byte *buffer, ulint size,
2951 bool *corrupt) const override;
2952
2953 void aggregate(PersistentTableMetadata &metadata,
2954 const PersistentTableMetadata &new_entry) const override;
2955};
2956
2957/** Container of persisters used in the system. Currently we don't need
2958to protect this object since we only initialize it at very beginning and
2959destroy it in the end. During the server running, we only get the persisters */
2961 typedef std::map<
2962 persistent_type_t, Persister *, std::less<persistent_type_t>,
2965
2966 public:
2967 /** Constructor */
2969
2970 /** Destructor */
2971 ~Persisters();
2972
2973 /** Get the persister object with specified type
2974 @param[in] type persister type
2975 @return Persister object required or NULL if not found */
2977
2978 /** Add a specified persister of type, we will allocate the Persister
2979 if there is no such persister exist, otherwise do nothing and return
2980 the existing one
2981 @param[in] type persister type
2982 @return the persister of type */
2984
2985 /** Remove a specified persister of type, we will free the Persister
2986 @param[in] type persister type */
2988
2989 /** Serialize the metadata to a buffer
2990 @param[in] metadata metadata to serialize
2991 @param[out] buffer buffer to store the serialized metadata
2992 @return the length of serialized metadata */
2993 size_t write(PersistentTableMetadata &metadata, byte *buffer);
2994
2995 private:
2996 /** A map to store all persisters needed */
2998};
2999
3000#ifndef UNIV_HOTBACKUP
3001
3002/** A function object to add the foreign key constraint to the referenced set
3003of the referenced table, if it exists in the dictionary cache. */
3005 void operator()(dict_foreign_t *foreign) const {
3006 if (dict_table_t *table = foreign->referenced_table) {
3007 std::pair<dict_foreign_set::iterator, bool> ret =
3008 table->referenced_set.insert(foreign);
3009 ut_a(ret.second);
3010 }
3011 }
3012};
3013
3014/** Request for lazy creation of the mutex of a given table.
3015This function is only called from either single threaded environment
3016or from a thread that has not shared the table object with other threads.
3017@param[in,out] table table whose mutex is to be created */
3019 table->mutex = nullptr;
3020 table->mutex_created = os_once::NEVER_DONE;
3021}
3022
3023/** Destroy the mutex of a given table.
3024This function is only called from either single threaded environment
3025or from a thread that has not shared the table object with other threads.
3026@param[in,out] table table whose mutex is to be created */
3028 if (table->mutex_created == os_once::DONE) {
3029 if (table->mutex != nullptr) {
3030 mutex_free(table->mutex);
3031 ut::delete_(table->mutex);
3032 }
3033 }
3034}
3035
3036/** Destroy the autoinc latch of the given table.
3037This function is only called from either single threaded environment
3038or from a thread that has not shared the table object with other threads.
3039@param[in,out] table table whose stats latch to destroy */
3041 if (table->autoinc_mutex_created == os_once::DONE) {
3042 if (table->autoinc_mutex != nullptr) {
3043 mutex_free(table->autoinc_mutex);
3044 ut::delete_(table->autoinc_mutex);
3045 }
3046
3047 if (table->autoinc_persisted_mutex != nullptr) {
3048 mutex_free(table->autoinc_persisted_mutex);
3049 ut::delete_(table->autoinc_persisted_mutex);
3050 }
3051 }
3052}
3053
3054/** Request for lazy creation of the autoinc latch of a given table.
3055This function is only called from either single threaded environment
3056or from a thread that has not shared the table object with other threads.
3057@param[in,out] table table whose autoinc latch is to be created. */
3059 table->autoinc_mutex = nullptr;
3060 table->autoinc_persisted_mutex = nullptr;
3061 table->autoinc_mutex_created = os_once::NEVER_DONE;
3062}
3063
3064/** Request a lazy creation of dict_index_t::zip_pad::mutex.
3065This function is only called from either single threaded environment
3066or from a thread that has not shared the table object with other threads.
3067@param[in,out] index index whose zip_pad mutex is to be created */
3069 index->zip_pad.mutex = nullptr;
3070 index->zip_pad.mutex_created = os_once::NEVER_DONE;
3071}
3072
3073/** Destroy the zip_pad_mutex of the given index.
3074This function is only called from either single threaded environment
3075or from a thread that has not shared the table object with other threads.
3076@param[in,out] index index whose stats latch to destroy */
3078 if (index->zip_pad.mutex_created == os_once::DONE &&
3079 index->zip_pad.mutex != nullptr) {
3080 mutex_free(index->zip_pad.mutex);
3081 ut::delete_(index->zip_pad.mutex);
3082 }
3083}
3084#endif /* !UNIV_HOTBACKUP */
3085
3086/** Release the zip_pad_mutex of a given index.
3087@param[in,out] index index whose zip_pad_mutex is to be released */
3089#ifndef UNIV_HOTBACKUP
3090 mutex_exit(index->zip_pad.mutex);
3091#endif /* !UNIV_HOTBACKUP */
3092}
3093
3094#ifdef UNIV_DEBUG
3095/** Check if the current thread owns the autoinc_mutex of a given table.
3096@param[in] table the autoinc_mutex belongs to this table
3097@return true, if the current thread owns the autoinc_mutex, false otherwise.*/
3099 return (mutex_own(table->autoinc_mutex));
3100}
3101#endif /* UNIV_DEBUG */
3102
3103#include "dict0mem.ic"
3104
3105#endif /* dict0mem_h */
uint32_t space_id_t
Tablespace identifier.
Definition: api0api.h:48
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:247
The index tree general types.
The database buffer pool high-level routines.
Persister used for autoinc counters.
Definition: dict0mem.h:2916
ulint write(const PersistentTableMetadata &metadata, byte *buffer, ulint size) const override
Write the autoinc counter of a table, we can pre-calculate the size by calling get_write_size()
Definition: dict0dict.cc:5648
ulint read(PersistentTableMetadata &metadata, const byte *buffer, ulint size, bool *corrupt) const override
Read the autoinc counter from buffer, and store them to metadata object.
Definition: dict0dict.cc:5675
void aggregate(PersistentTableMetadata &metadata, const PersistentTableMetadata &new_entry) const override
Aggregate metadata entries into a single metadata instance, considering version numbers.
Definition: dict0dict.cc:5695
ulint get_write_size(const PersistentTableMetadata &metadata) const override
Pre-calculate the size of metadata to be written.
Definition: dict0mem.h:2931
Persister used for corrupted indexes.
Definition: dict0mem.h:2877
ulint get_write_size(const PersistentTableMetadata &metadata) const override
Pre-calculate the size of metadata to be written.
Definition: dict0dict.cc:5566
static const size_t INDEX_ID_LENGTH
The length of index_id_t we will write.
Definition: dict0mem.h:2912
ulint read(PersistentTableMetadata &metadata, const byte *buffer, ulint size, bool *corrupt) const override
Read the corrupted indexes from buffer, and store them to metadata object.
Definition: dict0dict.cc:5594
ulint write(const PersistentTableMetadata &metadata, byte *buffer, ulint size) const override
Write the corrupted indexes of a table, we can pre-calculate the size by calling get_write_size()
Definition: dict0dict.cc:5530
void aggregate(PersistentTableMetadata &metadata, const PersistentTableMetadata &new_entry) const override
Aggregate metadata entries into a single metadata instance, considering version numbers.
Definition: dict0dict.cc:5633
Persistent dynamic metadata for a table.
Definition: dict0mem.h:2760
uint64_t get_autoinc() const
Get the autoinc counter of the table.
Definition: dict0mem.h:2807
table_id_t get_table_id() const
Get the table id of the metadata.
Definition: dict0mem.h:2789
void add_corrupted_index(const index_id_t id)
Add a corrupted index id and space id.
Definition: dict0mem.h:2776
const corrupted_ids_t & get_corrupted_indexes() const
Get the corrupted indexes' IDs.
Definition: dict0mem.h:2770
void set_version(uint64_t version)
Set the dynamic metadata version.
Definition: dict0mem.h:2782
void set_autoinc(uint64_t autoinc)
Set the autoinc counter of the table.
Definition: dict0mem.h:2803
uint64_t m_autoinc
Autoinc counter of the table.
Definition: dict0mem.h:2820
void set_autoinc_if_bigger(uint64_t autoinc)
Set the autoinc counter of the table if it's bigger.
Definition: dict0mem.h:2793
table_id_t m_id
Table ID which this metadata belongs to.
Definition: dict0mem.h:2811
uint64_t get_version() const
Get the dynamic metadata version.
Definition: dict0mem.h:2785
uint64_t m_version
Table dynamic metadata version of the change.
Definition: dict0mem.h:2814
corrupted_ids_t m_corrupted_ids
Storing the corrupted indexes' ID if exist, or else empty.
Definition: dict0mem.h:2817
PersistentTableMetadata(table_id_t id, uint64_t version)
Constructor.
Definition: dict0mem.h:2765
Interface for persistent dynamic table metadata.
Definition: dict0mem.h:2826
virtual ~Persister()=default
Virtual destructor.
void write_log(table_id_t id, const PersistentTableMetadata &metadata, mtr_t *mtr) const
Write MLOG_TABLE_DYNAMIC_META for persistent dynamic metadata of table.
Definition: dict0dict.cc:5495
virtual ulint write(const PersistentTableMetadata &metadata, byte *buffer, ulint size) const =0
Write the dynamic metadata of a table, we can pre-calculate the size by calling get_write_size()
virtual ulint read(PersistentTableMetadata &metadata, const byte *buffer, ulint size, bool *corrupt) const =0
Read the dynamic metadata from buffer, and store them to metadata object.
virtual ulint get_write_size(const PersistentTableMetadata &metadata) const =0
Pre-calculate the size of metadata to be written.
virtual void aggregate(PersistentTableMetadata &metadata, const PersistentTableMetadata &new_entry) const =0
Aggregate metadata entries into a single metadata instance, considering version numbers.
Container of persisters used in the system.
Definition: dict0mem.h:2960
persisters_t m_persisters
A map to store all persisters needed.
Definition: dict0mem.h:2997
std::map< persistent_type_t, Persister *, std::less< persistent_type_t >, ut::allocator< std::pair< const persistent_type_t, Persister * > > > persisters_t
Definition: dict0mem.h:2964
~Persisters()
Destructor.
Definition: dict0dict.cc:5707
void remove(persistent_type_t type)
Remove a specified persister of type, we will free the Persister.
Definition: dict0dict.cc:5761
size_t write(PersistentTableMetadata &metadata, byte *buffer)
Serialize the metadata to a buffer.
Definition: dict0dict.cc:5775
Persister * get(persistent_type_t type) const
Get the persister object with specified type.
Definition: dict0dict.cc:5717
Persisters()
Constructor.
Definition: dict0mem.h:2968
Persister * add(persistent_type_t type)
Add a specified persister of type, we will allocate the Persister if there is no such persister exist...
Definition: dict0dict.cc:5731
The state of the FTS sub system.
Definition: fts0fts.h:364
SQL identifier name wrapper for pretty-printing.
Definition: dict0mem.h:436
const char * operator()() const
Explicit type conversion.
Definition: dict0mem.h:457
id_name_t & operator=(const char *name)
Assignment operator.
Definition: dict0mem.h:446
const char * m_name
The name in internal representation.
Definition: dict0mem.h:461
id_name_t(const char *name)
Constructor.
Definition: dict0mem.h:442
id_name_t()
Default constructor.
Definition: dict0mem.h:439
Globally unique index identifier.
Definition: dict0types.h:237
Cache position of last inserted or selected record by caching record and holding reference to the blo...
Definition: dict0mem.h:987
last_ops_cur_t()
Constructor.
Definition: dict0mem.h:990
void release()
Definition: dict0mem.h:995
bool disable_caching
disable caching.
Definition: dict0mem.h:1015
mtr_t mtr
active mtr that will be re-used for next insert/select.
Definition: dict0mem.h:1012
buf_block_t * block
block where record reside.
Definition: dict0mem.h:1009
rec_t * rec
last inserted/selected record.
Definition: dict0mem.h:1006
bool invalid
If index structure is undergoing structural change viz.
Definition: dict0mem.h:1020
static const state_t NEVER_DONE
Not yet executed.
Definition: os0once.h:70
static const state_t DONE
Finished execution.
Definition: os0once.h:76
Page size descriptor.
Definition: page0size.h:50
Allocator that allows std::* containers to manage their memory through ut::malloc* and ut::free libra...
Definition: ut0new.h:2183
#define PERFORMANCE_SCHEMA_DB_NAME
Name of the performance schema database.
Definition: client_priv.h:215
Data types.
constexpr uint32_t DATA_MULTI_VALUE
Multi-value Virtual column.
Definition: data0type.h:225
ulint DATA_MBMINMAXLEN(ulint mbminlen, ulint mbmaxlen)
Definition: data0type.h:250
constexpr uint32_t DATA_MBMAX
Definition: data0type.h:238
static ulint dtype_get_max_size_low(ulint mtype, ulint len)
Returns the maximum size of a data type.
constexpr uint32_t DATA_VIRTUAL
Virtual column.
Definition: data0type.h:223
constexpr uint32_t DATA_ITT_N_SYS_COLS
number of system columns for intrinsic temporary table
Definition: data0type.h:197
constexpr uint32_t DATA_SYS
system column
Definition: data0type.h:75
ulint DATA_MBMINLEN(ulint mbminmaxlen)
Definition: data0type.h:255
ulint DATA_MBMAXLEN(ulint mbminmaxlen)
Definition: data0type.h:259
static ulint dtype_get_fixed_size_low(ulint mtype, ulint prtype, ulint len, ulint mbminmaxlen, bool comp)
Returns the size of a fixed size data type, 0 if not a fixed size type.
constexpr uint32_t DATA_NOT_NULL
this is ORed to the precise type when the column is declared as NOT NULL
Definition: data0type.h:207
constexpr uint32_t DATA_N_SYS_COLS
number of system columns defined above
Definition: data0type.h:194
static ulint dtype_get_min_size_low(ulint mtype, ulint prtype, ulint len, ulint mbminmaxlen)
Returns the minimum size of a data type.
bool DATA_GEOMETRY_MTYPE(ulint mtype)
Definition: data0type.h:269
void dict_mem_init(void)
Initialize dict memory variables.
Definition: dict0mem.cc:834
constexpr uint32_t DICT_CLUSTERED
Type flags of an index: OR'ing of the flags is allowed to define a combination of types.
Definition: dict0mem.h:96
void dict_table_autoinc_create_lazy(dict_table_t *table)
Request for lazy creation of the autoinc latch of a given table.
Definition: dict0mem.h:3058
char * dict_mem_create_temporary_tablename(mem_heap_t *heap, const char *dbtab, table_id_t id)
Create a temporary tablename like "#sql-ibtid-inc" where tid = the Table ID inc = a randomly initiali...
Definition: dict0mem.cc:812
void dict_mem_foreign_fill_vcol_set(dict_foreign_t *foreign)
Fills the dependent virtual columns in a set.
Definition: dict0mem.cc:498
static void DICT_TF2_FLAG_UNSET(dict_table_t *table, uint32_t flag)
Definition: dict0mem.h:2726
void dict_mem_foreign_table_name_lookup_set(dict_foreign_t *foreign, bool do_alloc)
Sets the foreign_table_name_lookup pointer based on the value of lower_case_table_names.
Definition: dict0mem.cc:365
constexpr uint32_t DICT_TF2_FTS_ADD_DOC_ID
Need to add Doc ID column for FTS index build.
Definition: dict0mem.h:279
constexpr uint32_t DICT_TF2_ENCRYPTION_FILE_PER_TABLE
Encryption table bit for innodb_file-per-table only.
Definition: dict0mem.h:295
constexpr uint32_t DICT_TF_BIT_MASK
A mask of all the known/used bits in table flags.
Definition: dict0mem.h:193
constexpr uint32_t DICT_IT_BITS
number of bits used for SYS_INDEXES.TYPE
Definition: dict0mem.h:115
void dict_index_zip_pad_mutex_destroy(dict_index_t *index)
Destroy the zip_pad_mutex of the given index.
Definition: dict0mem.h:3077
ulong zip_failure_threshold_pct
Percentage of compression failures that are allowed in a single round.
Definition: dict0dict.cc:181
constexpr uint32_t DICT_TF_WIDTH_SHARED_SPACE
Width of the SHARED tablespace flag.
Definition: dict0mem.h:184
std::set< dict_foreign_t *, dict_foreign_compare, ut::allocator< dict_foreign_t * > > dict_foreign_set
Definition: dict0mem.h:1751
table_dirty_status
The dirty status of tables, used to indicate if a table has some dynamic metadata changed to be writt...
Definition: dict0mem.h:1878
@ METADATA_CLEAN
All persistent metadata are up to date.
Definition: dict0mem.h:1897
@ METADATA_BUFFERED
Some persistent metadata is buffered in DDTableBuffer table, need to be written back to DD table.
Definition: dict0mem.h:1894
@ METADATA_DIRTY
Some persistent metadata is now dirty in memory, need to be written back to DDTableBuffer table and(o...
Definition: dict0mem.h:1890
constexpr uint32_t MAX_KEY_LENGTH_BITS
Definition: dict0mem.h:1037
constexpr char INSTANT_DROP_SUFFIX_8_0_29[]
Format of INSTANTLY DROPPED column names.
Definition: dict0mem.h:85
constexpr uint32_t DICT_N_COLS_COMPACT
This bitmask is used in SYS_TABLES.N_COLS to set and test whether the Compact page format is used,...
Definition: dict0mem.h:156
std::list< dict_v_idx_t, ut::allocator< dict_v_idx_t > > dict_v_idx_list
Index list to put in dict_v_col_t.
Definition: dict0mem.h:807
constexpr uint32_t DICT_FK_MAX_RECURSIVE_LOAD
Tables could be chained together with Foreign key constraint.
Definition: dict0mem.h:310
std::list< dict_s_col_t, ut::allocator< dict_s_col_t > > dict_s_col_list
list to put stored column for dict_table_t
Definition: dict0mem.h:854
static uint32_t DICT_MAX_FIELD_LEN_BY_FORMAT_FLAG(uint32_t flags)
Definition: dict0mem.h:879
void dict_table_mutex_destroy(dict_table_t *table)
Destroy the mutex of a given table.
Definition: dict0mem.h:3027
constexpr uint32_t DICT_MULTI_VALUE
Multi-value index.
Definition: dict0mem.h:112
constexpr uint32_t DICT_TF_POS_UNUSED
Zero relative shift position of the start of the UNUSED bits.
Definition: dict0mem.h:210
constexpr uint32_t DICT_TF2_FTS
The table has an FTS index.
Definition: dict0mem.h:275
uint32_t DICT_TF_HAS_SHARED_SPACE(uint32_t flags)
Return the value of the SHARED_SPACE field.
Definition: dict0mem.h:246
const char innobase_index_reserve_name[]
"GEN_CLUST_INDEX" is the name reserved for InnoDB default system clustered index when there is no pri...
Definition: dict0mem.h:1025
constexpr uint32_t DICT_SDI
Definition: dict0mem.h:110
constexpr uint32_t DICT_VIRTUAL
Index on Virtual column.
Definition: dict0mem.h:108
constexpr uint32_t DICT_TF_POS_SHARED_SPACE
Zero relative shift position of the SHARED TABLESPACE field.
Definition: dict0mem.h:207
dict_foreign_t * dict_mem_foreign_create(void)
Creates and initializes a foreign constraint memory object.
Definition: dict0mem.cc:342
constexpr uint32_t DICT_TF_MASK_SHARED_SPACE
Bit mask of the SHARED_SPACE field.
Definition: dict0mem.h:226
void dict_foreign_free(dict_foreign_t *foreign)
Frees a foreign key struct.
Definition: dict0mem.h:1782
std::vector< row_prebuilt_t * > temp_prebuilt_vec
A vector to collect prebuilt from different readers working on the same temp table.
Definition: dict0mem.h:1903
constexpr uint32_t DICT_CORRUPT
bit to store the corrupted flag in SYS_INDEXES.TYPE
Definition: dict0mem.h:102
constexpr uint32_t DICT_TF2_BIT_MASK
Definition: dict0mem.h:266
static void dict_mem_fill_index_struct(dict_index_t *index, mem_heap_t *heap, const char *table_name, const char *index_name, ulint space, ulint type, ulint n_fields)
This function poplulates a dict_index_t index memory structure with supplied information.
static bool DICT_TF2_FLAG_IS_SET(const dict_table_t *table, uint32_t flag)
Definition: dict0mem.h:2721
std::ostream & operator<<(std::ostream &out, const dict_foreign_t &foreign)
Definition: dict0mem.cc:899
constexpr uint32_t DICT_FOREIGN_ON_DELETE_SET_NULL
ON DELETE SET NULL.
Definition: dict0mem.h:1814
constexpr uint32_t DICT_FOREIGN_ON_DELETE_NO_ACTION
ON DELETE NO ACTION.
Definition: dict0mem.h:1820
constexpr uint32_t DICT_TF_COMPACT
dict_table_t::flags bit 0 is equal to 1 if the row format = Compact
Definition: dict0mem.h:152
bool dict_foreign_set_validate(const dict_foreign_set &fk_set)
Validate the search order in the foreign key set.
Definition: dict0mem.cc:850
void dict_mem_table_fill_foreign_vcol_set(dict_table_t *table)
Fill virtual columns set in each fk constraint present in the table.
Definition: dict0mem.cc:521
constexpr uint32_t DICT_TF_POS_ZIP_SSIZE
Zero relative shift position of the ZIP_SSIZE field.
Definition: dict0mem.h:198
constexpr uint32_t DICT_TF2_USE_FILE_PER_TABLE
This bit is used during table creation to indicate that it will use its own tablespace instead of the...
Definition: dict0mem.h:283
constexpr uint32_t DICT_TF_WIDTH_DATA_DIR
If a table is created with the MYSQL option DATA DIRECTORY and innodb-file-per-table,...
Definition: dict0mem.h:176
constexpr uint32_t DICT_TF2_AUX
FTS AUX hidden table bit.
Definition: dict0mem.h:298
constexpr uint32_t DICT_TF_REDUNDANT
dict_table_t::flags bit 0 is equal to 0 if the row format = Redundant
Definition: dict0mem.h:149
dict_v_col_t * dict_mem_table_add_v_col(dict_table_t *table, mem_heap_t *heap, const char *name, ulint mtype, ulint prtype, ulint len, ulint pos, ulint num_base, bool is_visible)
Adds a virtual column definition to a table.
Definition: dict0mem.cc:93
void dict_mem_table_free_foreign_vcol_set(dict_table_t *table)
Free the vcol_set from all foreign key constraint on the table.
Definition: dict0mem.cc:534
constexpr uint32_t DICT_FOREIGN_ON_UPDATE_NO_ACTION
ON UPDATE NO ACTION.
Definition: dict0mem.h:1822
persistent_type_t
Persistent dynamic metadata type, there should be 1 to 1 relationship between the metadata and the ty...
Definition: dict0mem.h:2735
@ PM_BIGGEST_TYPE
The biggest type, which should be 1 bigger than the last true type.
Definition: dict0mem.h:2754
@ PM_TABLE_AUTO_INC
Persistent Metadata type for autoinc counter.
Definition: dict0mem.h:2744
@ PM_INDEX_CORRUPTED
Persistent Metadata type for corrupted indexes.
Definition: dict0mem.h:2741
@ PM_SMALLEST_TYPE
The smallest type, which should be 1 less than the first true type.
Definition: dict0mem.h:2738
constexpr uint32_t FK_MAX_CASCADE_DEL
Similarly, when tables are chained together with foreign key constraints with on cascading delete/upd...
Definition: dict0mem.h:318
constexpr char INSTANT_DROP_PREFIX_8_0_32[]
Definition: dict0mem.h:86
static bool is_valid_row_version(const row_version_t version)
Definition: dict0mem.h:422
uint32_t DICT_TF_GET_ZIP_SSIZE(uint32_t flags)
Return the value of the ZIP_SSIZE field.
Definition: dict0mem.h:234
uint32_t DICT_TF_HAS_DATA_DIR(uint32_t flags)
Return the value of the DATA_DIR field.
Definition: dict0mem.h:242
constexpr uint32_t DICT_MAX_FIXED_COL_LEN
Defines the maximum fixed length column size.
Definition: dict0mem.h:887
constexpr uint32_t DICT_FTS
FTS index; can't be combined with the other flags.
Definition: dict0mem.h:104
constexpr uint32_t DICT_TF2_TEMPORARY
TEMPORARY; true for tables from CREATE TEMPORARY TABLE.
Definition: dict0mem.h:269
ulong zip_pad_max
Maximum percentage of a page that can be allowed as a pad to avoid compression failures.
Definition: dict0dict.cc:185
online_index_status
The status of online index creation.
Definition: dict0mem.h:1633
@ ONLINE_INDEX_ABORTED
secondary index creation was aborted and the index should be dropped as soon as index->table->n_ref_c...
Definition: dict0mem.h:1644
@ ONLINE_INDEX_ABORTED_DROPPED
the online index creation was aborted, the index was dropped from the data dictionary and the tablesp...
Definition: dict0mem.h:1649
@ ONLINE_INDEX_CREATION
the index is being created, online (allowing concurrent modifications)
Definition: dict0mem.h:1638
@ ONLINE_INDEX_COMPLETE
the index is complete and ready for access
Definition: dict0mem.h:1635
constexpr uint32_t DICT_TF2_DISCARDED
Set when we discard/detach the tablespace.
Definition: dict0mem.h:286
constexpr uint32_t DICT_TF2_BITS
Table Flags set number 2.
Definition: dict0mem.h:264
constexpr uint32_t DICT_TF_MASK_DATA_DIR
Bit mask of the DATA_DIR field.
Definition: dict0mem.h:223
constexpr uint32_t DICT_TF2_UNUSED_BIT_MASK
Definition: dict0mem.h:265
ut_list_base< lock_t, TableLockGetNode > table_lock_list_t
Definition: dict0mem.h:1841
constexpr uint32_t DICT_SPATIAL
SPATIAL index; can't be combined with the other flags.
Definition: dict0mem.h:106
constexpr uint32_t DICT_FOREIGN_ON_UPDATE_SET_NULL
ON UPDATE SET NULL.
Definition: dict0mem.h:1818
constexpr uint32_t DICT_TF_POS_ATOMIC_BLOBS
Zero relative shift position of the ATOMIC_BLOBS field.
Definition: dict0mem.h:201
std::set< dict_v_col_t *, std::less< dict_v_col_t * >, ut::allocator< dict_v_col_t * > > dict_vcol_set
Set to store the virtual columns which are affected by Foreign key constraint.
Definition: dict0mem.h:1656
void dict_mem_table_col_rename(dict_table_t *table, ulint nth_col, const char *from, const char *to, bool is_virtual)
Renames a column of a table in the data dictionary cache.
Definition: dict0mem.cc:318
constexpr uint32_t DICT_TF_BITS
Width of all the currently known table flags.
Definition: dict0mem.h:187
static void DICT_TF2_FLAG_SET(dict_table_t *table, uint32_t flag)
Definition: dict0mem.h:2717
constexpr uint32_t DICT_TF_MASK_ATOMIC_BLOBS
Bit mask of the ATOMIC_BLOBS field.
Definition: dict0mem.h:220
constexpr uint32_t ZIP_PAD_ROUND_LEN
PADDING HEURISTIC BASED ON LINEAR INCREASE OF PADDING TO AVOID COMPRESSION FAILURES (Note: this is re...
Definition: dict0mem.h:938
void dict_mem_table_add_s_col(dict_table_t *table, ulint num_base)
Adds a stored column definition to a table.
Definition: dict0mem.cc:150
constexpr uint32_t DICT_FOREIGN_ON_DELETE_CASCADE
The flags for ON_UPDATE and ON_DELETE can be ORed; the default is that a foreign key constraint is en...
Definition: dict0mem.h:1812
uint32_t DICT_TF_GET_COMPACT(uint32_t flags)
Return the value of the COMPACT field.
Definition: dict0mem.h:230
constexpr uint32_t ZIP_PAD_SUCCESSFUL_ROUND_LIMIT
Number of successful rounds after which the padding is decreased.
Definition: dict0mem.h:941
void dict_index_zip_pad_mutex_create_lazy(dict_index_t *index)
Request a lazy creation of dict_index_t::zip_pad::mutex.
Definition: dict0mem.h:3068
constexpr uint32_t DICT_UNIQUE
unique index
Definition: dict0mem.h:98
constexpr uint32_t DICT_TABLE_MAGIC_N
Value of 'magic_n'.
Definition: dict0mem.h:1908
constexpr uint32_t ZIP_PAD_INCR
Amount by which padding is increased.
Definition: dict0mem.h:944
constexpr uint32_t DICT_IBUF
insert buffer tree
Definition: dict0mem.h:100
constexpr uint32_t DICT_TF_MASK_COMPACT
Bit mask of the COMPACT field.
Definition: dict0mem.h:214
constexpr uint32_t DICT_INDEX_MAGIC_N
Value of dict_index_t::magic_n.
Definition: dict0mem.h:1033
void dict_table_autoinc_destroy(dict_table_t *table)
Destroy the autoinc latch of the given table.
Definition: dict0mem.h:3040
uint32_t DICT_TF_HAS_ATOMIC_BLOBS(uint32_t flags)
Return the value of the ATOMIC_BLOBS field.
Definition: dict0mem.h:238
constexpr uint32_t DICT_TF2_FTS_HAS_DOC_ID
The table has an internal defined DOC ID column.
Definition: dict0mem.h:272
constexpr uint32_t DICT_TF_POS_DATA_DIR
Zero relative shift position of the DATA_DIR field.
Definition: dict0mem.h:204
bool dict_table_autoinc_own(const dict_table_t *table)
Check if the current thread owns the autoinc_mutex of a given table.
Definition: dict0mem.h:3098
constexpr uint32_t DICT_TF_WIDTH_COMPACT
Width of the COMPACT flag.
Definition: dict0mem.h:159
constexpr char RECOVERY_INDEX_TABLE_NAME[]
index/table name used while applying REDO logs during recovery
Definition: dict0mem.h:89
constexpr uint32_t DICT_FOREIGN_ON_UPDATE_CASCADE
ON UPDATE CASCADE.
Definition: dict0mem.h:1816
constexpr uint32_t DICT_TF2_INTRINSIC
Intrinsic table bit Intrinsic table is table created internally by MySQL modules viz.
Definition: dict0mem.h:292
constexpr uint32_t DICT_TF2_RESURRECT_PREPARED
Table is opened by resurrected trx during crash recovery.
Definition: dict0mem.h:301
uint32_t DICT_TF_GET_UNUSED(uint32_t flags)
Return the contents of the UNUSED bits.
Definition: dict0mem.h:250
void dict_mem_referenced_table_name_lookup_set(dict_foreign_t *foreign, bool do_alloc)
Sets the referenced_table_name_lookup pointer based on the value of lower_case_table_names.
Definition: dict0mem.cc:389
constexpr uint32_t DICT_INDEX_MERGE_THRESHOLD_DEFAULT
Definition: dict0mem.h:1036
void dict_mem_index_free(dict_index_t *index)
Frees an index memory object.
Definition: dict0mem.cc:766
constexpr uint32_t DICT_TF_POS_COMPACT
Zero relative shift position of the COMPACT field.
Definition: dict0mem.h:196
constexpr uint32_t DICT_TF_WIDTH_ZIP_SSIZE
Width of the ZIP_SSIZE flag.
Definition: dict0mem.h:162
void dict_table_mutex_create_lazy(dict_table_t *table)
Request for lazy creation of the mutex of a given table.
Definition: dict0mem.h:3018
constexpr uint32_t DICT_ANTELOPE_MAX_INDEX_COL_LEN
DICT_ANTELOPE_MAX_INDEX_COL_LEN is measured in bytes and is the maximum indexed column length (or ind...
Definition: dict0mem.h:867
std::vector< index_id_t, ut::allocator< index_id_t > > corrupted_ids_t
Definition: dict0mem.h:2757
constexpr uint32_t DICT_TF_MASK_ZIP_SSIZE
Bit mask of the ZIP_SSIZE field.
Definition: dict0mem.h:217
constexpr uint32_t DICT_TF_WIDTH_ATOMIC_BLOBS
Width of the ATOMIC_BLOBS flag.
Definition: dict0mem.h:170
void dict_index_zip_pad_unlock(dict_index_t *index)
Release the zip_pad_mutex of a given index.
Definition: dict0mem.h:3088
Data dictionary memory object creation.
Data dictionary global types.
ib_id_t space_index_t
Index identifier (unique within a tablespace).
Definition: dict0types.h:234
spatial_status_t
whether a col is used in spatial index or regular index Note: the spatial status is part of persisten...
Definition: dict0types.h:346
@ SPATIAL_MIXED
Used in both spatial index and regular index.
Definition: dict0types.h:354
@ SPATIAL_NONE
Not used in gis index.
Definition: dict0types.h:351
@ SPATIAL_ONLY
Only used in spatial index.
Definition: dict0types.h:357
ib_id_t table_id_t
Table or partition identifier (unique within an InnoDB instance).
Definition: dict0types.h:232
ib_quiesce_t
Quiescing states for flushing tables to disk.
Definition: dict0types.h:311
Full text search header file.
R-tree header file.
The simple hash table utility.
void * hash_node_t
Definition: hash0hash.h:47
static int flags[50]
Definition: hp_test1.cc:40
static int flag
Definition: hp_test1.cc:40
The transaction lock system global types.
@ LOCK_NUM
Definition: lock0types.h:62
The memory management.
static void mem_heap_free(mem_heap_t *heap)
Frees the space occupied by a memory heap.
Data dictionary memory object creation.
#define mtr_commit(m)
Commit a mini-transaction.
Definition: mtr0mtr.h:59
void for_each(const Shards< COUNT > &shards, Function &&f) noexcept
Iterate over the shards.
Definition: ut0counter.h:323
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
The version of the current data dictionary table definitions.
Definition: dictionary_client.h:43
unsigned long long Object_id
Definition: object_id.h:31
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
bool index(const std::string &value, const String &search_for, uint32_t *idx)
Definition: contains.h:75
ValueType value(const std::optional< ValueType > &v)
Definition: gtid.h:83
size_t size(const char *const c)
Definition: base64.h:46
mutable_buffer buffer(void *p, size_t n) noexcept
Definition: buffer.h:418
const char * table_name
Definition: rules_table_service.cc:56
void delete_(T *ptr) noexcept
Releases storage which has been dynamically allocated through any of the ut::new*() variants.
Definition: ut0new.h:811
std::set< Key, Compare, ut::allocator< Key > > set
Specialization of set which uses ut_allocator.
Definition: ut0new.h:2884
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2894
A class that aids executing a given function exactly once in a multi-threaded environment.
Query graph global types.
Record manager global types.
const uint8_t MAX_ROW_VERSION
Definition: rem0types.h:46
constexpr uint32_t REC_ANTELOPE_MAX_INDEX_COL_LEN
Definition: rem0types.h:82
constexpr uint32_t REC_VERSION_56_MAX_INDEX_COL_LEN
Maximum indexed field length for tables that have atomic BLOBs.
Definition: rem0types.h:87
const row_version_t INVALID_ROW_VERSION
Definition: rem0types.h:56
byte rec_t
Definition: rem0types.h:41
uint16_t row_version_t
Definition: rem0types.h:53
required uint64 version
Definition: replication_group_member_actions.proto:41
required string type
Definition: replication_group_member_actions.proto:34
Row operation global types.
LEX_CSTRING MYSQL_SCHEMA_NAME
Definition: table.cc:144
LEX_CSTRING INFORMATION_SCHEMA_NAME
Definition: table.cc:137
File containing constants that can be used throughout the server.
constexpr const unsigned int MAX_KEY_LENGTH
Definition: sql_const.h:47
case opt name
Definition: sslopt-case.h:29
const char * str
Definition: mysql_lex_string.h:41
Definition: lock0priv.h:283
The search info struct in an index.
Definition: btr0sea.h:46
The buffer control block structure.
Definition: buf0buf.h:1764
Data structure for newly added virtual column in a table.
Definition: dict0mem.h:830
const dict_v_col_t * v_col
column structures
Definition: dict0mem.h:835
ulint n_v_col
number of new virtual column
Definition: dict0mem.h:832
const char ** v_col_name
new col names
Definition: dict0mem.h:838
Data structure for default value of a column in a table.
Definition: dict0mem.h:471
byte * value
Default value in bytes.
Definition: dict0mem.h:475
dict_col_t * col
Pointer to the column itself.
Definition: dict0mem.h:473
size_t len
Length of default value.
Definition: dict0mem.h:477
bool operator!=(const dict_col_default_t &other) const
Definition: dict0mem.cc:598
bool operator==(const dict_col_default_t &other) const
Definition: dict0mem.cc:576
Data structure for a column in a table.
Definition: dict0mem.h:484
uint16_t get_col_phy_pos() const
Definition: dict0mem.h:566
void copy_type(dtype_t *type) const
Gets the column data type.
Definition: dict0mem.h:662
unsigned ord_part
nonzero if this column appears in the ordering fields of an index
Definition: dict0mem.h:525
bool is_dropped_in_or_before(row_version_t version) const
Check if column is dropped before the given version.
Definition: dict0mem.h:735
void set_phy_pos(uint32_t pos)
Definition: dict0mem.h:578
void set_prefix_phy_pos(uint16_t prefix_pos)
Definition: dict0mem.h:559
row_version_t get_version_added() const
Definition: dict0mem.h:587
spatial_status_t get_spatial_status() const
Check whether the col is used in spatial index or regular index.
Definition: dict0mem.h:705
ulint get_null_size(ulint comp) const
Returns the ROW_FORMAT=REDUNDANT stored SQL NULL size of a column.
Definition: dict0mem.h:701
row_version_t version_added
Definition: dict0mem.h:543
bool is_visible
Definition: dict0mem.h:534
unsigned mtype
main data type
Definition: dict0mem.h:501
unsigned max_prefix
maximum index prefix length on this column.
Definition: dict0mem.h:528
ulint get_fixed_size(ulint comp) const
Returns the size of a fixed size column, 0 if not a fixed size column.
Definition: dict0mem.h:693
bool is_version_added_match(const dict_col_t *col) const
Definition: dict0mem.h:597
static bool is_instant_dropped_name(const std::string col_name)
Check if a column name resembles format for dropped column.
Definition: dict0mem.h:786
bool is_instant_added() const
Definition: dict0mem.h:580
ulint get_min_size() const
Returns the minimum size of the column.
Definition: dict0mem.h:640
void set_default(const byte *value, size_t length, mem_heap_t *heap)
Set default value.
Definition: dict0mem.cc:552
ulint get_mbminlen() const
Gets the minimum number of bytes per character.
Definition: dict0mem.h:673
bool is_version_dropped_match(const dict_col_t *col) const
Definition: dict0mem.h:626
bool is_nullable() const
Check if a column is nullable.
Definition: dict0mem.h:658
bool is_visible_in_version(row_version_t version) const
Check if a column is visible in given version.
Definition: dict0mem.h:761
void set_version_added(row_version_t version)
Definition: dict0mem.h:592
void set_col_phy_pos(uint16_t pos)
Definition: dict0mem.h:569
bool is_instant_dropped() const
Definition: dict0mem.h:609
bool is_multi_value() const
Check if a column is a multi-value virtual column.
Definition: dict0mem.h:654
row_version_t version_dropped
Definition: dict0mem.h:546
uint32_t phy_pos
Definition: dict0mem.h:540
ulint get_max_size() const
Returns the maximum size of the column.
Definition: dict0mem.h:646
bool is_added_after(row_version_t version) const
Check if column is added after the current version.
Definition: dict0mem.h:748
bool assert_equal(const dtype_t *type) const
Assert that a column and a data type match.
Definition: dict0mem.h:770
unsigned len
length; for MySQL data this is field->pack_length(), except that for a >= 5.0.3 type true VARCHAR thi...
Definition: dict0mem.h:505
dict_col_default_t * instant_default
The following are copied from dtype_t, so that all bit-fields can be packed tightly.
Definition: dict0mem.h:492
uint16_t get_prefix_phy_pos() const
Definition: dict0mem.h:553
bool is_virtual() const
Check if a column is a virtual column.
Definition: dict0mem.h:650
unsigned mbminmaxlen
minimum and maximum length of a character, in bytes; DATA_MBMINMAXLEN(mbminlen,mbmaxlen); mbminlen=DA...
Definition: dict0mem.h:514
row_version_t get_version_dropped() const
Definition: dict0mem.h:616
void set_version_dropped(row_version_t version)
Definition: dict0mem.h:621
void set_mbminmaxlen(ulint mbminlen, ulint mbmaxlen)
Sets the minimum and maximum number of bytes per character.
Definition: dict0mem.h:682
unsigned ind
table column position (starting from 0)
Definition: dict0mem.h:523
unsigned prtype
precise type; MySQL data type, charset code, flags to indicate nullability, signedness,...
Definition: dict0mem.h:494
ulint get_mbmaxlen() const
Gets the maximum number of bytes per character.
Definition: dict0mem.h:677
bool has_prefix_phy_pos() const
Definition: dict0mem.h:550
uint32_t get_phy_pos() const
Definition: dict0mem.h:575
Data structure for a field in an index.
Definition: dict0mem.h:890
dict_col_t * col
pointer to the table column
Definition: dict0mem.h:893
id_name_t name
name of the column
Definition: dict0mem.h:894
unsigned is_ascending
0=DESC, 1=ASC
Definition: dict0mem.h:906
unsigned prefix_len
0 or the length of the column prefix in bytes in a MySQL index of type, e.g., INDEX (textcol(25)); mu...
Definition: dict0mem.h:895
unsigned fixed_len
0 or the fixed length of the column if smaller than DICT_ANTELOPE_MAX_INDEX_COL_LEN
Definition: dict0mem.h:903
uint16_t get_phy_pos() const
Definition: dict0mem.h:908
dict_field_t()
Definition: dict0mem.h:891
A function object to add the foreign key constraint to the referenced set of the referenced table,...
Definition: dict0mem.h:3004
void operator()(dict_foreign_t *foreign) const
Definition: dict0mem.h:3005
Compare two dict_foreign_t objects using their ids.
Definition: dict0mem.h:1722
bool operator()(const dict_foreign_t *lhs, const dict_foreign_t *rhs) const
Definition: dict0mem.h:1723
Definition: dict0mem.h:1743
bool operator()(const dict_foreign_t *foreign) const
Definition: dict0mem.h:1744
Function object to check if a foreign key object is there in the given foreign key set or not.
Definition: dict0mem.h:1758
bool operator()(dict_foreign_t *const &foreign) const
Definition: dict0mem.h:1762
const dict_foreign_set & m_foreigns
Definition: dict0mem.h:1767
dict_foreign_not_exists(const dict_foreign_set &obj_)
Definition: dict0mem.h:1759
Definition: dict0mem.h:1709
void operator()(const dict_foreign_t *foreign)
Definition: dict0mem.h:1712
dict_foreign_print(std::ostream &out)
Definition: dict0mem.h:1710
std::ostream & m_out
Definition: dict0mem.h:1715
The destructor will free all the foreign key constraints in the set by calling dict_foreign_free() on...
Definition: dict0mem.h:1796
~dict_foreign_set_free()
Definition: dict0mem.h:1800
dict_foreign_set_free(const dict_foreign_set &foreign_set)
Definition: dict0mem.h:1797
const dict_foreign_set & m_foreign_set
Definition: dict0mem.h:1805
Data structure for a foreign key constraint; an example: FOREIGN KEY (A, B) REFERENCES TABLE2 (C,...
Definition: dict0mem.h:1661
unsigned type
0 or DICT_FOREIGN_ON_DELETE_CASCADE or DICT_FOREIGN_ON_DELETE_SET_NULL
Definition: dict0mem.h:1672
char * referenced_table_name_lookup
referenced table name for dict lookup
Definition: dict0mem.h:1681
dict_vcol_set * v_cols
set of virtual columns affected by foreign key constraint.
Definition: dict0mem.h:1694
char * referenced_table_name
referenced table name
Definition: dict0mem.h:1680
dict_table_t * referenced_table
table where the referenced key is
Definition: dict0mem.h:1683
char * foreign_table_name_lookup
foreign table name used for dict lookup
Definition: dict0mem.h:1675
const char ** referenced_col_names
names of the referenced columns in the referenced table
Definition: dict0mem.h:1685
const char ** foreign_col_names
names of the columns in the foreign key
Definition: dict0mem.h:1678
unsigned n_fields
number of indexes' first fields for which the foreign key constraint is defined: we allow the indexes...
Definition: dict0mem.h:1666
bool is_fts_col_affected() const
Check whether foreign key constraint contains a column with a full index on it.
Definition: dict0mem.cc:876
dict_table_t * foreign_table
table where the foreign key is
Definition: dict0mem.h:1677
char * foreign_table_name
foreign table name
Definition: dict0mem.h:1674
mem_heap_t * heap
this object is allocated from this memory heap
Definition: dict0mem.h:1662
dict_index_t * referenced_index
referenced index
Definition: dict0mem.h:1692
char * id
id of the constraint as a null-terminated string
Definition: dict0mem.h:1664
dict_index_t * foreign_index
foreign index; we require that both tables contain explicitly defined indexes for the constraint: Inn...
Definition: dict0mem.h:1687
A function object to find a foreign key with the given index as the referenced index.
Definition: dict0mem.h:1730
const dict_index_t * m_index
Definition: dict0mem.h:1737
dict_foreign_with_index(const dict_index_t *index)
Definition: dict0mem.h:1731
bool operator()(const dict_foreign_t *foreign) const
Definition: dict0mem.h:1733
Data structure for an index.
Definition: dict0mem.h:1041
uint32_t get_n_nullable_before(uint32_t nth) const
Returns the number of nullable fields before specified nth field.
Definition: dict0mem.h:1363
bool is_committed() const
Determine if the index has been committed to the data dictionary.
Definition: dict0mem.h:1266
unsigned uncommitted
a flag that is set for secondary indexes that have not been committed to the data dictionary yet
Definition: dict0mem.h:1126
const char * table_name
table name
Definition: dict0mem.h:1052
const dict_index_t * next() const
Get the next index.
Definition: dict0mem.h:1282
unsigned instant_cols
true if the index is clustered index and it has some instant columns
Definition: dict0mem.h:1129
rtr_ssn_t rtr_ssn
Node sequence number for RTree.
Definition: dict0mem.h:1223
rw_lock_t lock
read-write lock protecting the upper levels of the index tree
Definition: dict0mem.h:1236
id_name_t name
index name
Definition: dict0mem.h:1049
const byte * get_nth_default(ulint nth, ulint *length) const
Get the default value of nth field and its length if exists.
Definition: dict0mem.h:1570
unsigned type
index type (DICT_CLUSTERED, DICT_UNIQUE, DICT_IBUF, DICT_CORRUPT)
Definition: dict0mem.h:1068
uint32_t magic_n
magic number
Definition: dict0mem.h:1145
uint32_t get_nullable_in_version(row_version_t version) const
Return nullable in a specific row version.
Definition: dict0mem.h:1431
uint64_t * stat_n_sample_sizes
number of pages that were sampled to calculate each of stat_n_diff_key_vals[], e.g.
Definition: dict0mem.h:1195
uint32_t get_n_total_fields() const
Returns total fields including INSTANT DROP fields.
Definition: dict0mem.h:1381
bool has_instant_cols_or_row_versions() const
check if either instant or versioned.
Definition: dict0mem.h:1347
void destroy_fields_array()
Definition: dict0mem.h:1450
unsigned n_total_fields
number of total fields in the index (including INSTANT dropped fields)
Definition: dict0mem.h:1104
dict_field_t * get_physical_field(size_t pos) const
Gets the nth physical pos field.
Definition: dict0mem.h:1483
uint32_t get_instant_fields() const
Returns the number of fields before first instant ADD COLUMN.
Definition: dict0mem.ic:92
unsigned trx_id_offset
position of the trx id column in a clustered index record, if the fields before it are known to be of...
Definition: dict0mem.h:1072
void create_fields_array()
Create fields array sorted by phy_pos of field in row.
Definition: dict0mem.h:1438
uint16_t get_field_off_pos(ulint pos) const
Get the physical position of a field on a row.
Definition: dict0mem.h:1521
void set_instant_nullable(uint16_t n)
Set instant nullable.
Definition: dict0mem.h:1243
trx_id_t trx_id
id of the transaction that created this index, or 0 if the index existed when InnoDB was started up
Definition: dict0mem.h:1230
bool fill_dd
Flag whether need to fill dd tables when it's a fulltext index.
Definition: dict0mem.h:1239
const dict_col_t * get_col(ulint pos) const
Gets pointer to the nth column in an index.
Definition: dict0mem.h:1544
std::unique_ptr< dd::Spatial_reference_system > rtr_srs
Cached spatial reference system dictionary entry used by R-tree indexes.
Definition: dict0mem.h:1142
dict_field_t * fields
array of field descriptions
Definition: dict0mem.h:1149
uint32_t srid
spatial reference id
Definition: dict0mem.h:1135
last_ops_cur_t * last_ins_cur
cache the last insert position.
Definition: dict0mem.h:1211
ulint get_col_pos(ulint n, bool inc_prefix=false, bool is_virtual=false) const
Looks for column n in an index.
Definition: dict0mem.cc:733
ulint stat_n_leaf_pages
approximate number of leaf pages in the index tree
Definition: dict0mem.h:1206
space_id_t space_id() const
Get the space id of the tablespace to which this index belongs.
Definition: dict0mem.h:1629
uint32_t has_multi_value_col(const dict_v_col_t *mv_col) const
Check if a multi-value index is built on specified multi-value virtual column.
Definition: dict0mem.h:1605
void add_field(const char *name_arg, ulint prefix_len, bool is_ascending)
Adds a field definition to an index.
Definition: dict0mem.h:1466
uint16_t get_instant_nullable() const
Get instant nullable.
Definition: dict0mem.h:1247
unsigned nulls_equal
if true, SQL NULL == SQL NULL
Definition: dict0mem.h:1086
bool is_usable(const trx_t *trx) const
Check whether index can be used by transaction.
Definition: dict0mem.cc:604
UT_LIST_NODE_T(dict_index_t) indexes
list of indexes of the table
unsigned row_versions
true if the index is clustered index and table has row versions
Definition: dict0mem.h:1132
uint16_t get_field_phy_pos(ulint pos, row_version_t version) const
Definition: dict0mem.h:1525
unsigned n_instant_nullable
number of nullable fields before first instant ADD COLUMN applied to this table.
Definition: dict0mem.h:1111
unsigned space
space where the index tree is placed
Definition: dict0mem.h:1058
unsigned cached
true if the index object is in the dictionary cache
Definition: dict0mem.h:1114
ulint get_sys_col_pos(ulint type) const
Returns the position of a system column in an index.
Definition: dict0mem.cc:716
uint64_t * stat_n_diff_key_vals
Statistics for query optimization.
Definition: dict0mem.h:1190
zip_pad_info_t zip_pad
Information about state of compression failures and successes.
Definition: dict0mem.h:1233
dict_field_t * get_field(ulint pos) const
Gets the nth field of an index.
Definition: dict0mem.h:1497
row_log_t * online_log
the log of modifications during online index creation; valid when online_status is ONLINE_INDEX_CREAT...
Definition: dict0mem.h:1182
uint16_t get_nullable_before_instant_add_drop() const
Get the nullable fields before any INSTANT ADD/DROP.
Definition: dict0mem.h:1251
unsigned disable_ahi
if true, then disable AHI.
Definition: dict0mem.h:1091
uint64_t * stat_n_non_null_key_vals
Definition: dict0mem.h:1200
ulint get_min_size() const
Returns the minimum data size of an index record.
Definition: dict0mem.h:1322
size_t calculate_n_instant_nullable(size_t _n_fields) const
Definition: dict0mem.h:1390
unsigned n_def
number of fields defined so far
Definition: dict0mem.h:1098
unsigned n_nullable
number of nullable fields
Definition: dict0mem.h:1107
rec_cache_t rec_cache
cache the field that needs to be re-computed on each insert.
Definition: dict0mem.h:1220
bool is_multi_value() const
Check whether the index is the multi-value index.
Definition: dict0mem.h:1314
last_ops_cur_t * last_sel_cur
cache the last selected position.
Definition: dict0mem.h:1215
unsigned n_fields
number of fields in the index
Definition: dict0mem.h:1101
uint16_t get_logical_pos(uint16_t phy_pos) const
Given the physical position, find the logical position of field.
Definition: dict0mem.h:1507
st_mysql_ftparser * parser
fulltext parser plugin
Definition: dict0mem.h:1161
uint32_t nullables[MAX_ROW_VERSION+1]
Number of nullable columns in each version.
Definition: dict0mem.h:1157
bool has_row_versions() const
Check whether index belongs to a table having row versions.
Definition: dict0mem.h:1343
space_index_t id
id of the index
Definition: dict0mem.h:1043
void set_committed(bool committed)
Flag an index committed or uncommitted.
Definition: dict0mem.h:1273
bool is_compressed() const
Check if the underlying table is compressed.
Definition: dict0mem.h:2730
void create_nullables(uint32_t current_row_version)
Create nullables array.
Definition: dict0mem.cc:622
bool is_corrupted() const
Check whether the index is corrupted.
Definition: dict0mem.h:1297
bool srid_is_valid
says whether SRID is valid - it cane be undefined
Definition: dict0mem.h:1138
rtr_info_track_t * rtr_track
tracking all R-Tree search cursors
Definition: dict0mem.h:1226
dict_index_t * next()
Get the next index.
Definition: dict0mem.h:1290
bool is_clustered() const
Definition: dict0mem.h:1306
bool has_instant_cols() const
Check whether index has any instantly added columns.
Definition: dict0mem.h:1339
ulint get_col_no(ulint pos) const
Gets the column number the nth field in an index.
Definition: dict0mem.cc:709
mem_heap_t * heap
memory heap
Definition: dict0mem.h:1046
unsigned merge_threshold
In the pessimistic delete, if the page data size drops below this limit in percent,...
Definition: dict0mem.h:1065
std::vector< uint16_t > fields_array
Array of field pos sorted as per their physical pos in record.
Definition: dict0mem.h:1153
dict_table_t * table
back pointer to table
Definition: dict0mem.h:1055
bool is_ngram
true if it's ngram parser
Definition: dict0mem.h:1164
unsigned online_status
enum online_index_status.
Definition: dict0mem.h:1122
bool has_new_v_col
whether it has a newly added virtual column in ALTER
Definition: dict0mem.h:1167
page_size_t get_page_size() const
Get the page size of the tablespace to which this index belongs.
Definition: dict0mem.cc:917
bool is_tuple_instant_format(const uint16_t n_fields_in_tuple) const
Check if tuple is having instant format.
Definition: dict0mem.cc:672
unsigned allow_duplicates
if true, allow duplicate values even if index is created with unique constraint
Definition: dict0mem.h:1083
void fill_srid_value(uint32_t srid_value, bool srid_is_valid_value)
Sets srid and srid_is_valid values.
Definition: dict0mem.h:1589
bool hidden
if the index is an hidden index
Definition: dict0mem.h:1170
unsigned page
index tree root page number
Definition: dict0mem.h:1061
unsigned n_user_defined_cols
number of columns the user defined to be in the index: in the internal representation we add more col...
Definition: dict0mem.h:1075
btr_search_t * search_info
info used in optimistic searches
Definition: dict0mem.h:1177
unsigned to_be_dropped
true if the index is to be dropped; protected by dict_operation_lock
Definition: dict0mem.h:1117
ulint stat_index_size
approximate index size in database pages
Definition: dict0mem.h:1203
unsigned n_uniq
number of fields from the beginning which are enough to determine an index entry uniquely
Definition: dict0mem.h:1095
Data structure for a stored column in a table.
Definition: dict0mem.h:842
dict_col_t * m_col
Stored column ptr.
Definition: dict0mem.h:844
ulint s_pos
column pos in table
Definition: dict0mem.h:850
dict_col_t ** base_col
array of base col ptr
Definition: dict0mem.h:846
ulint num_base
number of base columns
Definition: dict0mem.h:848
Data structure for a database table.
Definition: dict0mem.h:1913
uint32_t stats_auto_recalc
Indicates whether the table uses automatic recalc for persistent stats or not.
Definition: dict0mem.h:2261
bool has_instant_cols() const
Definition: dict0mem.h:2498
bool refresh_fk
refresh/reload FK info
Definition: dict0mem.h:2450
bool support_instant_add_drop() const
Determine if the table can support instant ADD/DROP COLUMN.
Definition: dict0dict.ic:1370
dict_vcol_templ_t * vc_templ
mysql_row_templ_t for base columns used for compute the virtual columns
Definition: dict0mem.h:2444
dict_col_t * get_col_by_name(const char *name) const
Get column by name.
Definition: dict0mem.h:2604
bool has_row_versions() const
Definition: dict0mem.h:2483
unsigned n_cols
Number of non-virtual columns.
Definition: dict0mem.h:2055
rw_lock_t * stats_latch
This latch protects: "dict_table_t::stat_initialized", "dict_table_t::stat_n_rows (*)",...
Definition: dict0mem.h:2219
std::atomic< const trx_t * > autoinc_trx
The transaction that currently holds the the AUTOINC lock on this table.
Definition: dict0mem.h:2371
ulint stat_clustered_index_size
Approximate clustered index size in database pages.
Definition: dict0mem.h:2273
uint32_t get_n_instant_add_cols() const
Get number of columns added instantly.
Definition: dict0mem.h:2531
void unlock()
Unlock the table handle.
Definition: dict0dict.ic:1211
const char * get_col_name(ulint col_nr) const
Returns a column's name.
Definition: dict0mem.h:2577
std::atomic< ulint > n_foreign_key_checks_running
Count of how many foreign key check operations are currently being performed on the table.
Definition: dict0mem.h:2175
unsigned drop_aborted
true if some indexes should be dropped after ONLINE_INDEX_ABORTED or ONLINE_INDEX_ABORTED_DROPPED.
Definition: dict0mem.h:2087
ulint magic_n
Magic number.
Definition: dict0mem.h:2440
dict_foreign_set foreign_set
set of foreign key constraints which refer to this table
Definition: dict0mem.h:2184
UT_LIST_BASE_NODE_T(dict_index_t, indexes) indexes
List of indexes of the table.
bool skip_gap_locks() const
Definition: dict0dict.ic:1365
table_lock_list_t locks
List of locks on the table.
Definition: dict0mem.h:2406
unsigned to_be_dropped
true if the table is to be dropped, but not yet actually dropped (could in the background drop list).
Definition: dict0mem.h:2049
dict_col_t * get_col(uint pos) const
Gets the nth column of a table.
Definition: dict0mem.h:2594
uint64_t version
metadata version number of dd::Table::se_private_data()
Definition: dict0mem.h:2133
id_name_t tablespace
NULL or the tablespace name that this table is assigned to, specified by the TABLESPACE option.
Definition: dict0mem.h:1998
unsigned ibd_file_missing
true if this is in a single-table tablespace and the .ibd file is missing.
Definition: dict0mem.h:2039
hash_node_t name_hash
Hash chain node.
Definition: dict0mem.h:2116
unsigned n_instant_cols
Number of non-virtual columns before first instant ADD COLUMN, including the system columns like n_co...
Definition: dict0mem.h:2060
unsigned n_v_def
Number of virtual columns defined so far.
Definition: dict0mem.h:2069
ulint stats_sample_pages
The number of pages to sample for this table during persistent stats estimation.
Definition: dict0mem.h:2266
size_t get_index_count() const
Definition: dict0mem.h:2127
unsigned skip_alter_undo
true if the table is an intermediate table during copy alter operation or a partition/subpartition wh...
Definition: dict0mem.h:2034
bool explicitly_non_lru
true if this table is explicitly put to non-LRU list during table creation
Definition: dict0mem.h:2464
bool is_system_table
True if the table belongs to a system database (mysql, information_schema or performance_schema)
Definition: dict0mem.h:2113
std::atomic< size_t > n_rec_locks
Count of the number of record locks on this table.
Definition: dict0mem.h:2393
size_t get_n_instant_added_col_v1() const
Definition: dict0mem.h:2521
unsigned flags2
Stores information about: 1 whether the table has been created using CREATE TEMPORARY TABLE,...
Definition: dict0mem.h:2027
void lock()
Lock the table handle.
Definition: dict0dict.ic:1202
ib_quiesce_t quiesce
Quiescing states, protected by the dict_index_t::lock.
Definition: dict0mem.h:2383
bool has_pk() const
Check if the table has user defined primary key (PK).
Definition: dict0mem.cc:921
unsigned n_t_def
Number of total columns defined so far.
Definition: dict0mem.h:2066
void set_instant_cols(uint16_t n_inst_cols)
Set the number of columns when the first instant ADD COLUMN happens.
Definition: dict0mem.h:2510
unsigned flags
Stores information about: 1 row format (redundant or compact), 2 compressed page size (zip shift size...
Definition: dict0mem.h:2014
ulint autoinc_field_no
The position of autoinc counter field in clustered index.
Definition: dict0mem.h:2363
uint64_t sess_row_id
row-id counter for use by intrinsic table for getting row-id.
Definition: dict0mem.h:2424
void acquire()
Acquire the table handle.
Definition: dict0dict.ic:1160
uint16_t get_instant_cols() const
Get the number of user columns when the first instant ADD COLUMN happens.
Definition: dict0mem.h:2517
std::atomic< table_dirty_status > dirty_status
table dynamic metadata status, protected by dict_persist->mutex
Definition: dict0mem.h:2151
table_id_t id
Id of the table.
Definition: dict0mem.h:1974
UT_LIST_NODE_T(dict_table_t) table_LRU
Node of the LRU list of tables.
unsigned cached
true if the table object has been added to the dictionary cache.
Definition: dict0mem.h:2042
dict_index_t * first_index()
Definition: dict0mem.h:2477
bool is_temporary() const
Determine if this is a temporary table.
Definition: dict0mem.h:2679
bool discard_after_ddl
remove the dict_table_t from cache after DDL operation
Definition: dict0mem.h:2447
uint16_t get_n_user_cols() const
Gets the number of user-defined non-virtual columns in a table in the dictionary cache.
Definition: dict0mem.h:2624
void acquire_with_lock()
Acquire the table handle, with lock() and unlock() the table.
Definition: dict0dict.ic:1166
trx_id_t def_trx_id
Transaction id that last touched the table definition.
Definition: dict0mem.h:2180
ulint get_total_cols() const
Gets the number of all non-virtual columns in a table including columns dropped INSTANTly.
Definition: dict0mem.h:2652
dd::Object_id dd_space_id
dd::Tablespace::id of the table
Definition: dict0mem.h:2004
uint32_t total_col_count
Total non-virtual column count.
Definition: dict0mem.h:2145
dict_s_col_list * s_cols
List of stored column descriptions.
Definition: dict0mem.h:2100
unsigned n_m_v_cols
Number of multi-value virtual columns.
Definition: dict0mem.h:2075
unsigned n_t_cols
Number of total columns (include virtual and non-virtual)
Definition: dict0mem.h:2063
ib_mutex_t * mutex
Mutex of the table for concurrency access.
Definition: dict0mem.h:1967
table_id_t parent_id
If FTS AUX table, parent table id.
Definition: dict0mem.h:2279
uint64_t stat_modified_counter
How many rows are modified since last stats recalc.
Definition: dict0mem.h:2287
void release()
Release the table handle.
Definition: dict0dict.ic:1182
bool is_compressed() const
Check if the table is compressed.
Definition: dict0mem.h:1916
uint64_t autoinc
Autoinc counter value to give to the next inserted row.
Definition: dict0mem.h:2337
ulint stat_sum_of_other_index_sizes
Approximate size of other indexes in database pages.
Definition: dict0mem.h:2276
dict_col_t * get_sys_col(ulint sys) const
Gets the given system column of a table.
Definition: dict0mem.h:2665
void get_table_name(std::string &schema, std::string &table) const
Get schema and table name in system character set.
Definition: dict0dd.cc:7294
bool is_system_schema() const
Definition: dict0mem.h:1951
dict_foreign_set referenced_set
Definition: dict0mem.h:2187
unsigned n_def
Number of non-virtual columns defined so far.
Definition: dict0mem.h:2052
unsigned fk_max_recusive_level
Maximum recursive level we support when loading tables chained together with FK constraints.
Definition: dict0mem.h:2170
uint16_t get_n_sys_cols() const
Gets the number of system columns in a table.
Definition: dict0mem.h:2634
std::atomic< os_once::state_t > mutex_created
Creation state of mutex.
Definition: dict0mem.h:1970
uint64_t autoinc_persisted
Autoinc counter value that has been persisted in redo logs or DDTableBuffer.
Definition: dict0mem.h:2357
bool is_encrypted() const
Check if the table is encrypted.
Definition: dict0mem.h:1920
bool has_instant_add_cols() const
check if table has INSTANT ADD columns.
Definition: dict0mem.h:2544
fts_t * fts
FTS specific state variables.
Definition: dict0mem.h:2377
std::atomic< std::chrono::system_clock::time_point > update_time
Timestamp of the last modification of this table.
Definition: dict0mem.h:2423
bool is_intrinsic() const
Determine whether the table is intrinsic.
Definition: dict0mem.h:2700
ib_mutex_t * autoinc_mutex
Mutex protecting the autoincrement counter.
Definition: dict0mem.h:2334
bool can_be_evicted
true if this table is expected to be kept in memory.
Definition: dict0mem.h:2079
ulong count_by_mode[LOCK_NUM]
count_by_mode[M] = number of locks in this->locks with lock->type_mode&LOCK_MODE_MASK == M.
Definition: dict0mem.h:2419
dict_v_col_t * v_cols
Array of virtual column descriptions.
Definition: dict0mem.h:2093
temp_prebuilt_vec * temp_prebuilt
multiple cursors can be active on this temporary table
Definition: dict0mem.h:2454
void set_upgraded_instant()
Set table to be upgraded table with INSTANT ADD columns in V1.
Definition: dict0mem.h:2551
mem_heap_t * heap
Memory heap.
Definition: dict0mem.h:1985
dict_index_t * fts_doc_id_index
The FTS_DOC_ID_INDEX, or NULL if no fulltext indexes exist.
Definition: dict0mem.h:2122
table_name_t trunc_name
Truncate name.
Definition: dict0mem.h:1991
unsigned stat_initialized
true if statistics have been calculated the first time after database startup or table creation.
Definition: dict0mem.h:2223
uint64_t sess_trx_id
trx_id counter for use by intrinsic table for getting trx-id.
Definition: dict0mem.h:2436
byte stats_bg_flag
The state of the background stats thread wrt this table.
Definition: dict0mem.h:2305
std::atomic< uint64_t > n_ref_count
Count of how many handles are opened to this table.
Definition: dict0mem.h:2401
unsigned n_v_cols
Number of virtual columns.
Definition: dict0mem.h:2072
bool in_dirty_dict_tables_list
This field is used to mark if a table is in the dirty_dict_tables_list.
Definition: dict0mem.h:2164
std::chrono::steady_clock::time_point stats_last_recalc
Timestamp of last recalc of the stats.
Definition: dict0mem.h:2226
bool is_corrupted() const
Check whether the table is corrupted.
Definition: dict0mem.h:2559
ulint get_n_cols() const
Gets the number of all non-virtual columns (also system) in a table in the dictionary cache.
Definition: dict0mem.h:2643
const char * col_names
Column names packed in a character string "name1\0name2\0...nameN\0".
Definition: dict0mem.h:2106
table_name_t name
Table name.
Definition: dict0mem.h:1988
char * data_dir_path
NULL or the directory path specified by DATA DIRECTORY.
Definition: dict0mem.h:1994
const dict_index_t * first_index() const
Definition: dict0mem.h:2471
uint64_t get_ref_count() const
Get reference count.
Definition: dict0dict.ic:1157
lock_t * autoinc_lock
AUTOINC related members.
Definition: dict0mem.h:2327
uint32_t stat_persistent
Indicates whether the table uses persistent stats or not.
Definition: dict0mem.h:2243
uint32_t initial_col_count
Initial non-virtual column count.
Definition: dict0mem.h:2139
const char * v_col_names
Virtual column names.
Definition: dict0mem.h:2109
uint32_t current_col_count
Current non-virtual column count.
Definition: dict0mem.h:2142
unsigned big_rows
true if the maximum length of a single row exceeds BIG_ROW_SIZE.
Definition: dict0mem.h:2200
hash_node_t id_hash
Hash chain node.
Definition: dict0mem.h:2119
bool m_upgraded_instant
Set if table is upgraded instant table.
Definition: dict0mem.h:2148
bool has_instant_drop_cols() const
check if table has INSTANT DROP columns.
Definition: dict0mem.h:2548
uint64_t stat_n_rows
Approximate number of rows in the table.
Definition: dict0mem.h:2270
bool is_fts_aux() const
Determine if this is a FTS AUX table.
Definition: dict0mem.h:2685
uint32_t get_n_instant_drop_cols() const
Get number of columns dropped instantly.
Definition: dict0mem.h:2537
uint32_t current_row_version
Current row version in case columns are added/dropped INSTANTly.
Definition: dict0mem.h:2136
std::atomic< os_once::state_t > autoinc_mutex_created
Creation state of autoinc_mutex member.
Definition: dict0mem.h:2330
bool is_dd_table
true only for dictionary tables like mysql/tables, mysql/columns, mysql/tablespaces,...
Definition: dict0mem.h:2460
bool is_upgraded_instant() const
Checks if table is upgraded table with INSTANT ADD columns in V1.
Definition: dict0mem.h:2555
UT_LIST_NODE_T(dict_table_t) dirty_dict_tables
Node of the dirty table list of tables, which is protected by dict_persist->mutex.
std::atomic< os_once::state_t > stats_latch_created
Statistics for query optimization.
Definition: dict0mem.h:2206
ib_mutex_t * autoinc_persisted_mutex
Mutex protecting the persisted autoincrement counter.
Definition: dict0mem.h:2340
bool does_not_fit_in_memory
This field is used to specify in simulations tables which are so big that disk should be accessed.
Definition: dict0mem.h:2195
unsigned ddl_not_evictable
true if this table is not evictable(can_be_evicted) and this is because of DDL operation
Definition: dict0mem.h:2083
dict_col_t * cols
Array of column descriptions.
Definition: dict0mem.h:2090
space_id_t space
Space where the clustered index of the table is placed.
Definition: dict0mem.h:2001
Data structure for a virtual column in a table.
Definition: dict0mem.h:810
dict_v_idx_list * v_indexes
Virtual index list, and column position in the index, the allocated memory is not from table->heap,...
Definition: dict0mem.h:826
ulint v_pos
column pos in table
Definition: dict0mem.h:821
dict_col_t m_col
column structure
Definition: dict0mem.h:812
ulint num_base
number of base columns
Definition: dict0mem.h:818
dict_col_t ** base_col
array of base column ptr
Definition: dict0mem.h:815
Index information put in a list of virtual column structure.
Definition: dict0mem.h:798
ulint nth_field
position in this index
Definition: dict0mem.h:803
dict_index_t * index
active index on the column
Definition: dict0mem.h:800
Structure defines template related to virtual columns and their base columns.
Definition: dict0mem.h:1850
byte * default_rec
default column value if any
Definition: dict0mem.h:1873
ulint n_v_col
number of virtual columns
Definition: dict0mem.h:1855
std::string tb_name
table name
Definition: dict0mem.h:1864
ulint rec_len
MySQL record length.
Definition: dict0mem.h:1870
std::string share_name
share->table_name
Definition: dict0mem.h:1867
ulint n_col
number of regular columns
Definition: dict0mem.h:1852
mysql_row_templ_t ** vtempl
array of templates for virtual col and their base columns
Definition: dict0mem.h:1858
std::string db_name
table's database name
Definition: dict0mem.h:1861
Definition: data0type.h:498
Red black tree instance.
Definition: ut0rbt.h:72
Lock struct; protected by lock_sys latches.
Definition: lock0priv.h:137
The info structure stored at the beginning of a heap block.
Definition: mem0mem.h:302
Mini-transaction handle and buffer.
Definition: mtr0mtr.h:177
bool is_active() const
Definition: mtr0mtr.h:510
Definition: row0mysql.h:455
If key is fixed length key then cache the record offsets on first computation.
Definition: dict0mem.h:975
size_t nullable_cols
Number of NULLable columns among those for which offsets are cached.
Definition: dict0mem.h:980
const ulint * offsets
Holds reference to cached offsets for record.
Definition: dict0mem.h:977
Buffer for logging modifications during online index creation.
Definition: row0log.cc:185
Definition: gis0type.h:152
Definition: gis0type.h:160
The structure used in the spin lock implementation of a read-write lock.
Definition: sync0rw.h:363
Definition: plugin_ftparser.h:216
Table name wrapper for pretty-printing.
Definition: dict0mem.h:465
char * m_name
The name in internal representation.
Definition: dict0mem.h:467
Definition: trx0trx.h:675
Data structure to hold information about about how much space in an uncompressed page should be left ...
Definition: dict0mem.h:957
SysMutex * mutex
mutex protecting the info
Definition: dict0mem.h:958
ulint success
successful compression ops during current round
Definition: dict0mem.h:960
std::atomic< ulint > pad
number of bytes used as pad
Definition: dict0mem.h:959
ulint n_rounds
number of currently successful rounds
Definition: dict0mem.h:964
ulint failure
failed compression ops during current round
Definition: dict0mem.h:962
std::atomic< os_once::state_t > mutex_created
Creation state of mutex member.
Definition: dict0mem.h:967
The read-write lock (for threads, not for database transactions)
Transaction system global type definitions.
ib_id_t trx_id_t
Transaction identifier (DB_TRX_ID, DATA_TRX_ID)
Definition: trx0types.h:138
Definition: dtoa.cc:595
Version control for database, common definitions, and include files.
constexpr uint32_t UINT32_UNDEFINED
The 'undefined' value for a 32-bit unsigned integer.
Definition: univ.i:428
#define UNIV_LIKELY(cond)
Definition: univ.i:519
constexpr uint32_t UNIV_SQL_NULL
The following number as the length of a logical field means that the field has the SQL NULL as its va...
Definition: univ.i:463
constexpr uint16_t UINT16_UNDEFINED
The 'undefined' value for a 16-bit unsigned integer.
Definition: univ.i:431
unsigned long int ulint
Definition: univ.i:406
Utilities for byte operations.
#define ut_ad(EXPR)
Debug assertion.
Definition: ut0dbg.h:105
#define ut_a(EXPR)
Abort execution if EXPR does not evaluate to nonzero.
Definition: ut0dbg.h:93
#define UT_LIST_GET_LEN(BASE)
Alternative macro to get the number of nodes in a two-way list, i.e., its length.
Definition: ut0lst.h:441
#define UT_LIST_GET_FIRST(BASE)
Gets the first node in a two-way list.
Definition: ut0lst.h:446
#define UT_LIST_GET_NEXT(NAME, N)
Gets the next node in a two-way list.
Definition: ut0lst.h:429
Memory primitives.
static int ut_strcmp(const char *str1, const char *str2)
Wrapper for strcmp(3).
#define mutex_own(M)
Checks that the current thread owns the mutex.
Definition: ut0mutex.h:165
#define mutex_exit(M)
Definition: ut0mutex.h:123
#define mutex_free(M)
Definition: ut0mutex.h:125
Dynamic memory allocation routines and custom allocators specifically crafted to support memory instr...
Random numbers and hashing.
unsigned long id[MAX_DEAD]
Definition: xcom_base.cc:510
int n
Definition: xcom_base.cc:509