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