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