Data dictionary interface. More...

#include <auto_thd.h>
#include <current_thd.h>
#include <sql/thd_raii.h>
#include <sql_backup_lock.h>
#include <sql_class.h>
#include <sql_thd_internal_api.h>
#include "item.h"
#include <dd/properties.h>
#include "dict0crea.h"
#include "dict0dd.h"
#include "dict0dict.h"
#include "dict0mem.h"
#include "dict0priv.h"
#include "sql/dd/impl/types/column_impl.h"
#include "sql/dd/types/column_type_element.h"
#include "dict0stats.h"
#include "data0type.h"
#include "fil0fil.h"
#include "mach0data.h"
#include "rem0rec.h"
#include "fts0priv.h"
#include "gis/rtree_support.h"
#include "srv0start.h"
#include "ut0crc32.h"
#include "btr0sea.h"
#include "derror.h"
#include "fts0plugin.h"
#include "ha_innodb.h"
#include "ha_innopart.h"
#include "ha_prototypes.h"
#include "mysql/plugin.h"
#include "mysql/strings/m_ctype.h"
#include "query_options.h"
#include "sql/create_field.h"
#include "sql/mysqld.h"
#include "sql_base.h"
#include "sql_table.h"
#include "univ.i"

Namespaces
namespace	dict_name
	Innodb data dictionary name.

Functions
bool	dd_is_valid_row_version (uint32_t version)
	Determine if give version is a valid row version. More...

bool	dd_column_is_added (const dd::Column *dd_col)
	Determine if column is INSTANT ADD. More...

bool	dd_column_is_dropped (const dd::Column *dd_col)
	Determine if column is INSTANT DROP. More...

uint32_t	dd_column_get_version_added (const dd::Column *dd_col)
	Get the row version in which column is INSTANT ADD. More...

uint32_t	dd_column_get_version_dropped (const dd::Column *dd_col)
	Get the row version in which column is INSTANT DROP. More...

template<typename Index >
static bool	dd_index_match (const dict_index_t index, const Index dd_index)
	Check if the InnoDB index is consistent with dd::Index. More...

template<typename Table >
bool	dd_table_match (const dict_table_t table, const Table dd_table)
	Check if the InnoDB table is consistent with dd::Table. More...

template bool	dd_table_match< dd::Table > (const dict_table_t , const dd::Table )

template bool	dd_table_match< dd::Partition > (const dict_table_t , const dd::Partition )

void	dd_mdl_release (THD thd, MDL_ticket *mdl)
	Release a metadata lock. More...

THD *	dd_thd_for_undo (const trx_t &trx)
	Returns thd associated with the trx or current_thd. More...

bool	dd_mdl_for_undo (const trx_t &trx)
	Check if current undo needs a MDL or not. More...

int	acquire_uncached_table (THD thd, dd::cache::Dictionary_client client, const dd::Table dd_table, const char name, TABLE_SHARE ts, TABLE td)
	Open uncached table definition based on a Global DD object. More...

void	release_uncached_table (TABLE_SHARE ts, TABLE td)
	free uncached table definition. More...

int	dd_table_open_on_dd_obj (THD thd, dd::cache::Dictionary_client client, const dd::Table &dd_table, const dd::Partition dd_part, const char tbl_name, dict_table_t &table, const TABLE td)
	Instantiate an InnoDB in-memory table metadata (dict_table_t) based on a Global DD object or MYSQL table definition. More...

static dict_table_t *	dd_table_open_on_id_low (THD thd, MDL_ticket *mdl, table_id_t table_id)
	Load an InnoDB table definition by InnoDB table ID. More...

static int	dd_check_corrupted (dict_table_t *&table)
	Check if access to a table should be refused. More...

dict_table_t *	dd_table_open_on_id (table_id_t table_id, THD thd, MDL_ticket *mdl, bool dict_locked, bool check_corruption)
	Open a persistent InnoDB table based on InnoDB table id, and hold Shared MDL lock on it. More...

bool	dd_table_discard_tablespace (THD thd, const dict_table_t table, dd::Table *table_def, bool discard)
	Set the discard flag for a non-partitioned dd table. More...

dict_table_t *	dd_table_open_on_name (THD thd, MDL_ticket mdl, const char name, bool dict_locked, ulint ignore_err, int *error)
	Open an internal handle to a persistent InnoDB table by name. More...

void	dd_table_close (dict_table_t table, THD thd, MDL_ticket **mdl, bool dict_locked)
	Close an internal InnoDB table handle. More...

static void	replace_space_name_in_file_name (dd::Tablespace_file *dd_file, dd::String_type new_space_name)
	Replace the tablespace name in the file name. More...

static void	to_lower (std::string &name)
	Convert string to lower case. More...

dberr_t	dd_update_table_and_partitions_after_dir_change (dd::Object_id object_id, std::string path)
	Update the data directory flag in dd::Table key strings. More...

dberr_t	dd_tablespace_rename (dd::Object_id dd_space_id, bool is_system_cs, const char new_space_name, const char new_path)
	Update the tablespace name and file name for rename operation. More...

static bool	format_validate (THD thd, const TABLE form, row_type real_type, bool zip_allowed, bool strict, bool is_redundant, bool blob_prefix, ulint *zip_ssize, bool is_implicit)
	Validate the table format options. More...

void	dd_set_autoinc (dd::Properties &se_private_data, uint64_t autoinc)
	Set the AUTO_INCREMENT attribute. More...

void	dd_copy_autoinc (const dd::Properties &src, dd::Properties &dest)
	Copy the AUTO_INCREMENT and version attribute if exist. More...

void	dd_copy_instant_n_cols (dd::Table &new_table, const dd::Table &old_table)
	Copy the metadata of a table definition if there was an instant ADD COLUMN happened. More...

template<typename Table >
void	dd_copy_private (Table &new_table, const Table &old_table)
	Copy the engine-private parts of a table or partition definition when the change does not affect InnoDB. More...

template void	dd_copy_private< dd::Table > (dd::Table &, const dd::Table &)

template void	dd_copy_private< dd::Partition > (dd::Partition &, const dd::Partition &)

bool	is_renamed (const Alter_inplace_info ha_alter_info, const char old_name, std::string &new_name)
	Check if given column is renamed during ALTER. More...

bool	is_dropped (const Alter_inplace_info ha_alter_info, const char column_name)
	Check if given column is dropped during ALTER. More...

void	dd_copy_table_columns (const Alter_inplace_info ha_alter_info, dd::Table &new_table, const dd::Table &old_table, dict_table_t old_dict_table)
	Copy the engine-private parts of column definitions of a table. More...

void	dd_part_adjust_table_id (dd::Table *new_table)
	Adjust TABLE_ID for partitioned table after ALTER TABLE ... PARTITION. More...

dberr_t	dd_clear_instant_table (dd::Table &dd_table, bool clear_version)
	Clear the instant ADD COLUMN information of a table. More...

void	dd_clear_instant_part (dd::Partition &dd_part)
	Clear the instant ADD COLUMN information of a partition, to make it as a normal partition. More...

bool	dd_instant_columns_consistent (const dd::Table &dd_table)
	Check if the instant columns are consistent with the se_private_data in dd::Table. More...

void	dd_visit_keys_with_too_long_parts (const TABLE *table, const size_t max_part_len, std::function< void(const KEY &)> visitor)
	Scan through all the keys to identify the key parts which are greater than the maximum size supported by the table record format. More...

static void	instant_update_table_cols_count (dict_table_t *dict_table, uint32_t n_added_column, uint32_t n_dropped_column)

bool	copy_dropped_columns (const dd::Table old_dd_table, dd::Table new_dd_table, uint32_t current_row_version)
	Copy metadata of already dropped columns from old table def to new table def. More...

static void	set_dropped_column_name (std::string &name, uint32_t version, uint32_t phy_pos)

bool	dd_drop_instant_columns (const dd::Table old_dd_table, dd::Table new_dd_table, dict_table_t new_dict_table, const Columns &cols_to_drop, const Columns &cols_to_add, Alter_inplace_info ha_alter_info)
	Drop column instantly. More...

bool	dd_add_instant_columns (const dd::Table old_dd_table, dd::Table new_dd_table, dict_table_t *new_dict_table, const Columns &cols_to_add)
	Add column default values for new instantly added columns. More...

bool	dd_match_default_value (const dd::Column dd_col, const dict_col_t col)
	Compare the default values between imported column and column defined in the server. More...

void	dd_write_default_value (const dict_col_t col, dd::Column dd_col)
	Write default value of a column to dd::Column. More...

void	dd_parse_default_value (const dd::Properties &se_private_data, dict_col_t col, mem_heap_t heap)
	Parse the default value from dd::Column::se_private to dict_col_t. More...

static void	validate_dropped_col_metadata (const dd::Table dd_table, const dict_table_t table)

void	dd_import_instant_add_columns (const dict_table_t table, dd::Table dd_table)
	Import all metadata which is related to instant ADD COLUMN of a table to dd::Table. More...

template<typename Index >
static void	dd_write_index (dd::Object_id dd_space_id, Index dd_index, const dict_index_t index)
	Write metadata of a index to dd::Index. More...

template void	dd_write_index< dd::Index > (dd::Object_id, dd::Index , const dict_index_t )

template void	dd_write_index< dd::Partition_index > (dd::Object_id, dd::Partition_index , const dict_index_t )

template<typename Table >
void	dd_write_table (dd::Object_id dd_space_id, Table dd_table, const dict_table_t table)
	Write metadata of a table to dd::Table. More...

template void	dd_write_table< dd::Table > (dd::Object_id, dd::Table , const dict_table_t )

template void	dd_write_table< dd::Partition > (dd::Object_id, dd::Partition , const dict_table_t )

template<typename Table >
void	dd_set_table_options (Table dd_table, const dict_table_t table)
	Set options of dd::Table according to InnoDB table object. More...

template void	dd_set_table_options< dd::Table > (dd::Table , const dict_table_t )

template void	dd_set_table_options< dd::Partition > (dd::Partition , const dict_table_t )

void	dd_update_v_cols (dd::Table *dd_table, table_id_t id)
	Update virtual columns with new se_private_data, currently, only table_id is set. More...

void	dd_write_tablespace (dd::Tablespace *dd_space, space_id_t space_id, uint32_t fsp_flags, dd_space_states state)
	Write metadata of a tablespace to dd::Tablespace. More...

void	dd_add_fts_doc_id_index (dd::Table &new_table, const dd::Table &old_table)
	Add fts doc id column and index to new table when old table has hidden fts doc id without fulltext index. More...

template<typename Index >
const dict_index_t *	dd_find_index (const dict_table_t table, Index dd_index)
	Find the specified dd::Index or dd::Partition_index in an InnoDB table. More...

static uint16_t	get_index_prefix_len (const KEY &key, const KEY_PART_INFO *key_part)
	Return the prefix length of the key. More...

template const dict_index_t *	dd_find_index< dd::Index > (const dict_table_t , dd::Index )

template const dict_index_t *	dd_find_index< dd::Partition_index > (const dict_table_t , dd::Partition_index )

static int	dd_fill_one_dict_index (const dd::Index dd_index, dict_table_t table, const TABLE_SHARE *form, uint key_num)
	Create an index. More...

static ulint	dd_parse_merge_threshold (THD thd, const char str)
	Parse MERGE_THRESHOLD value from a comment string. More...

void	dd_copy_from_table_share (THD thd, dict_table_t table, const TABLE_SHARE *table_share)
	Copy attributes from MySQL TABLE_SHARE into an InnoDB table object. More...

int	dd_fill_dict_index (const dd::Table &dd_table, const TABLE m_form, dict_table_t m_table, THD *m_thd)
	Instantiate index related metadata. More...

bool	dd_table_contains_fulltext (const dd::Table &table)
	Determine if a table contains a fulltext index. More...

static void	dd_fill_instant_columns_default (const dd::Table &dd_table, dict_table_t *table)
	Read the metadata of default values for all columns added instantly. More...

static void	fill_dict_dropped_column (const dd::Column column, dict_table_t dict_table, uint32_t &crv, mem_heap_t *heap)

void	get_field_types (const dd::Table dd_tab, const dict_table_t m_table, const Field *field, unsigned &col_len, ulint &mtype, ulint &prtype)
	Get the mtype, prtype and len for a field. More...

static void	validate_index_len (dict_table_t m_table, const TABLE table)
	Check if the individual parts of the composite index does not exceed the limit based on the table row format. More...

template<typename Table >
static void	fill_dict_existing_column (const Table dd_tab, const TABLE m_form, dict_table_t m_table, uint32_t &crv, mem_heap_t heap, const uint32_t pos, bool has_row_versions)

void	fill_dict_dropped_columns (const dd::Table dd_table, dict_table_t dict_table, uint32_t &crv, mem_heap_t *heap)
	Add definition of INSTANT dropped column in table cache. More...

template<typename Table >
static void	fill_dict_columns (const Table dd_table, const TABLE m_form, dict_table_t dict_table, const unsigned n_mysql_cols, mem_heap_t heap, bool add_doc_id)

template<typename Table >
static dict_table_t *	dd_fill_dict_table (const Table dd_tab, const TABLE m_form, const char norm_name, HA_CREATE_INFO create_info, bool zip_allowed, bool strict, THD *m_thd, bool is_implicit)
	Instantiate in-memory InnoDB table metadata (dict_table_t), without any indexes. More...

bool	dd_create_tablespace (dd::cache::Dictionary_client dd_client, const char dd_space_name, space_id_t space_id, uint32_t flags, const char *filename, bool discarded, dd::Object_id &dd_space_id)
	Create metadata for specified tablespace, acquiring exclusive MDL first. More...

bool	dd_create_implicit_tablespace (dd::cache::Dictionary_client dd_client, space_id_t space_id, const char space_name, const char *filename, bool discarded, dd::Object_id &dd_space_id)
	Create metadata for implicit tablespace. More...

bool	dd_drop_tablespace (dd::cache::Dictionary_client *dd_client, dd::Object_id dd_space_id)
	Drop a tablespace. More...

bool	dd_tablespace_is_implicit (const dd::Tablespace dd_space, bool implicit)
	Determine if a tablespace is implicit. More...

bool	dd_get_tablespace_size_option (dd::cache::Dictionary_client dd_client, const dd::Object_id dd_space_id, uint64_t autoextend_size)
	Get the autoextend_size attribute for a tablespace. More...

bool	dd_implicit_alter_tablespace (dd::cache::Dictionary_client dd_client, dd::Object_id dd_space_id, HA_CREATE_INFO create_info)
	Set the autoextend_size attribute for an implicit tablespace. More...

bool	dd_set_tablespace_compression (dd::cache::Dictionary_client client, const char algorithm, dd::Object_id dd_space_id)
	Set Innodb tablespace compression option from DD. More...

dberr_t	dd_table_load_fk_from_dd (dict_table_t m_table, const dd::Table dd_table, const char **col_names, dict_err_ignore_t ignore_err, bool dict_locked)
	Load foreign key constraint info for the dd::Table object. More...

dberr_t	dd_table_load_fk (dd::cache::Dictionary_client client, const char tbl_name, const char *col_names, dict_table_t m_table, const dd::Table dd_table, THD thd, bool dict_locked, bool check_charsets, dict_names_t *fk_tables)
	Load foreign key constraint for the table. More...

dberr_t	dd_table_check_for_child (dd::cache::Dictionary_client client, const char tbl_name, const char *col_names, dict_table_t m_table, bool check_charsets, dict_err_ignore_t ignore_err, dict_names_t *fk_tables)
	Load foreign key constraint for the table. More...

template<typename Table >
const char *	dd_table_get_space_name (const Table *dd_table)
	Get tablespace name of dd::Table. More...

template<typename Table >
char *	dd_get_first_path (mem_heap_t heap, dict_table_t table, Table *dd_table)
	Get the first filepath from mysql.tablespace_datafiles for a given space_id. More...

template<typename Table >
void	dd_get_and_save_data_dir_path (dict_table_t table, const Table dd_table, bool dict_mutex_own)
	Make sure the data_dir_path is saved in dict_table_t if DATA DIRECTORY was used. More...

template void	dd_get_and_save_data_dir_path< dd::Table > (dict_table_t , const dd::Table , bool)

template void	dd_get_and_save_data_dir_path< dd::Partition > (dict_table_t , const dd::Partition , bool)

void	dd_get_meta_data_filename (dict_table_t table, dd::Table dd_table, char *filename, ulint max_len)
	Get the meta-data filename from the table name for a single-table tablespace. More...

template<typename Table >
void	dd_load_tablespace (const Table dd_table, dict_table_t table, mem_heap_t *heap, dict_err_ignore_t ignore_err, uint32_t expected_fsp_flags)
	Opens a tablespace for dd_load_table_one() More...

template<typename Table >
char *	dd_space_get_name (mem_heap_t heap, dict_table_t table, Table *dd_table)
	Get the space name from mysql.tablespaces for a given space_id. More...

template<typename Table >
void	dd_get_and_save_space_name (dict_table_t table, const Table dd_table, bool dict_mutex_own)
	Make sure the tablespace name is saved in dict_table_t if the table uses a general tablespace. More...

template void	dd_get_and_save_space_name< dd::Table > (dict_table_t , const dd::Table , bool)

template void	dd_get_and_save_space_name< dd::Partition > (dict_table_t , const dd::Partition , bool)

template<typename Table >
dict_table_t *	dd_open_table_one (dd::cache::Dictionary_client client, const TABLE table, const char norm_name, const Table dd_table, THD *thd, dict_names_t &fk_list)
	Open or load a table definition based on a Global DD object. More...

static void	dd_open_table_one_on_name (const char name, bool dict_locked, dict_names_t &fk_list, THD thd)
	Open single table with name. More...

void	dd_open_fk_tables (dict_names_t &fk_list, bool dict_locked, THD *thd)
	Open foreign tables reference a table. More...

template<typename Table >
dict_table_t *	dd_open_table (dd::cache::Dictionary_client client, const TABLE table, const char norm_name, const Table dd_table, THD *thd)
	Open or load a table definition based on a Global DD object. More...

template dict_table_t *	dd_open_table< dd::Table > (dd::cache::Dictionary_client , const TABLE , const char , const dd::Table , THD *)

template dict_table_t *	dd_open_table< dd::Partition > (dd::cache::Dictionary_client , const TABLE , const char , const dd::Partition , THD *)

static const rec_t *	dd_getnext_system_low (btr_pcur_t pcur, mtr_t mtr)
	Get next record from a new dd system table, like mysql.tables... More...

const rec_t *	dd_getnext_system_rec (btr_pcur_t pcur, mtr_t mtr)
	Get next record of new DD system tables. More...

const rec_t *	dd_startscan_system (THD thd, MDL_ticket mdl, btr_pcur_t pcur, mtr_t mtr, const char system_table_name, dict_table_t **table)
	Scan a new dd system table, like mysql.tables... More...

const char *	dd_process_dd_tables_rec_and_mtr_commit (mem_heap_t heap, const rec_t rec, dict_table_t *table, dict_table_t dd_tables, MDL_ticket *mdl, mtr_t mtr)
	Process one mysql.tables record and get the dict_table_t. More...

const char *	dd_process_dd_partitions_rec_and_mtr_commit (mem_heap_t heap, const rec_t rec, dict_table_t *table, dict_table_t dd_tables, MDL_ticket *mdl, mtr_t mtr)
	Process one mysql.table_partitions record and get the dict_table_t. More...

bool	dd_process_dd_columns_rec (mem_heap_t heap, const rec_t rec, dict_col_t col, table_id_t table_id, char *col_name, ulint nth_v_col, const dict_table_t dd_columns, mtr_t mtr)
	Process one mysql.columns record and get info to dict_col_t. More...

bool	dd_process_dd_virtual_columns_rec (mem_heap_t heap, const rec_t rec, table_id_t table_id, ulint pos, ulint base_pos, ulint n_row, dict_table_t dd_columns, mtr_t mtr)
	Process one mysql.columns record for virtual columns. More...

bool	dd_process_dd_indexes_rec (mem_heap_t heap, const rec_t rec, const dict_index_t index, MDL_ticket mdl, dict_table_t parent, MDL_ticket parent_mdl, dict_table_t dd_indexes, mtr_t mtr)
	Process one mysql.indexes record and get the dict_index_t. More...

bool	dd_process_dd_indexes_rec_simple (mem_heap_t heap, const rec_t rec, space_index_t index_id, space_id_t space_id, dict_table_t *dd_indexes)
	Process one mysql.indexes record and get brief info to dict_index_t. More...

bool	dd_process_dd_tablespaces_rec (mem_heap_t heap, const rec_t rec, space_id_t space_id, char name, uint32_t flags, uint32_t server_version, uint32_t space_version, bool is_encrypted, uint64_t autoextend_size, dd::String_type state, dict_table_t dd_spaces)
	Process one mysql.tablespaces record and get info. More...

static bool	dd_get_or_assign_fts_tablespace_id (const dict_table_t parent_table, const dict_table_t table, dd::Object_id &dd_space_id)
	Get dd tablespace id for fts table. More...

void	dd_set_fts_table_options (dd::Table dd_table, const dict_table_t table)
	Set table options for fts dd tables according to dict table. More...

static void	dd_set_fts_nullability (dd::Column dd_col, const dict_col_t col)
	Add nullability info to column se_private_data. More...

bool	dd_create_fts_index_table (const dict_table_t parent_table, dict_table_t table, const CHARSET_INFO *charset)
	Create dd table for fts aux index table. More...

bool	dd_create_fts_common_table (const dict_table_t parent_table, dict_table_t table, bool is_config)
	Create dd table for fts aux common table. More...

bool	dd_drop_fts_table (const char *name, bool file_per_table)
	Drop dd table & tablespace for fts aux table. More...

bool	dd_rename_fts_table (const dict_table_t table, const char old_name)
	Rename dd table & tablespace files for fts aux table. More...

void	dd_tablespace_set_space_id (dd::Tablespace *dd_space, space_id_t space_id)
	Set the space_id attribute in se_private_data of tablespace. More...

void	dd_tablespace_set_state (THD *thd, dd::Object_id dd_space_id, std::string space_name, dd_space_states dd_state)
	Set the 'state' value in dd:tablespace::se_private_data starting with an object id and the space name. More...

void	dd_tablespace_set_state (dd::Tablespace *dd_space, dd_space_states state)
	Set the 'state' value in dd:tablespace::se_private_data. More...

bool	dd_tablespace_set_id_and_state (const char *space_name, space_id_t space_id, dd_space_states state)
	Set Space ID and state attribute in se_private_data of mysql.tablespaces for the named tablespace. More...

void	dd_set_discarded (dd::Table &table, bool discard)
	Sets appropriate discard attribute of dd::Table Please note that this function must not be called on partitioned tables. More...

void	dd_set_discarded (dd::Partition &partition, bool discard)
	Sets appropriate discard attribute of dd::Partition Please note that this function can be only called on leaf_partitions. More...

void	dd_tablespace_get_state (const dd::Tablespace dd_space, dd::String_type state, space_id_t space_id)
	Get state attribute value in dd::Tablespace::se_private_data. More...

void	dd_tablespace_get_state (const dd::Properties p, dd::String_type state, space_id_t space_id)
	Get state attribute value in dd::Tablespace::se_private_data. More...

dd_space_states	dd_tablespace_get_state_enum (const dd::Tablespace *dd_space, space_id_t space_id)
	Get the enum for the state of the undo tablespace from either dd::Tablespace::se_private_data or undo::Tablespace. More...

dd_space_states	dd_tablespace_get_state_enum (const dd::Properties *p, space_id_t space_id)
	Get the enum for the state of a tablespace from either dd::Tablespace::se_private_data or undo::Tablespace. More...

dd_space_states	dd_tablespace_get_state_enum_legacy (const dd::Properties *p, space_id_t space_id)
	Get the enum for the state of a tablespace. More...

bool	dd_tablespace_is_discarded (const dd::Tablespace *dd_space)
	Get the discarded state from se_private_data of tablespace. More...

bool	dd_tablespace_get_mdl (const char space_name, MDL_ticket *mdl_ticket, bool foreground)
	Get the MDL for the named tablespace. More...

void	dd_release_mdl (MDL_ticket *mdl_ticket)
	Release the MDL held by the given ticket. More...

uint32_t	dd_get_total_indexes_num ()

char *	dd_get_referenced_table (const char name, const char database_name, ulint database_name_len, const char table_name, ulint table_name_len, dict_table_t table, MDL_ticket mdl, mem_heap_t heap)
	Open a table from its database and table name, this is currently used by foreign constraint parser to get the referenced table. More...

bool	dd_tablespace_update_cache (THD *thd)
	Update all InnoDB tablespace cache objects. More...

bool	dd_is_table_in_encrypted_tablespace (const dict_table_t *table)

void	dict_name::file_to_table (std::string &name, bool quiet)
	Conversion function to change for system to file name cs. More...

void	dict_name::table_to_file (std::string &name)
	Conversion function to change for file name to system cs. More...

static void	dict_name::get_partition_separators (bool is_57, std::string &part_sep, std::string &sub_part_sep)
	Get partition and sub-partition separator strings. More...

static bool	dict_name::check_partition (const std::string &dict_name, bool sub_part, size_t &position)
	Check for partition and sub partition. More...

static bool	dict_name::check_tmp (const std::string &dict_name, size_t &position)
	Check for TMP extension name. More...

bool	dict_name::is_partition (const std::string &dict_name)
	Check if it is a table partition. More...

void	dict_name::get_table (const std::string &dict_name, std::string &schema, std::string &table)
	Get schema and table name from dictionary table name. More...

void	dict_name::get_table (const std::string &dict_name, bool convert, std::string &schema, std::string &table, std::string &partition, bool &is_tmp)
	Get schema, table name, partition string and temporary attribute from dictionary table name. More...

std::optional< table_name_components >	dict_name::parse_tablespace_path (std::string path)
	Get schema, table name, partition, subpartition and absolute directory from dictionary from filepath. More...

void	dict_name::get_partition (const std::string &partition, bool convert, std::string &part, std::string &sub_part)
	Get partition and sub-partition name from partition string. More...

void	dict_name::build_table (const std::string &schema, const std::string &table, const std::string &partition, bool is_tmp, bool convert, std::string &dict_name)

static void	dict_name::build_partition_low (const std::string part, const std::string sub_part, Convert_Func conv, bool is_57, std::string &partition)
	Build partition string from partition and sub-partition name. More...

static void	dict_name::get_part_from_dd (const dd::Partition *dd_part, bool lower_case, std::string &part_name, std::string &sub_name)
	Get partition and sub-partition name from DD. More...

void	dict_name::build_partition (const dd::Partition *dd_part, std::string &partition)
	Build partition string from dd object. More...

void	dict_name::build_57_partition (const dd::Partition *dd_part, std::string &partition)
	Build 5.7 style partition string from dd object. More...

bool	dict_name::match_partition (const std::string &dict_name, const dd::Partition *dd_part)
	Check if dd partition matches with innodb dictionary table name. More...

static void	dict_name::get_table_parts (const std::string &dict_name, std::string &schema, std::string &table, std::string &partition, bool &is_tmp)
	Get table and partition string in system cs from dictionary name. More...

void	dict_name::convert_to_space (std::string &dict_name)

void	dict_name::rebuild_space (const std::string &dict_name, std::string &space_name)

void	dict_name::rebuild (std::string &dict_name)
	Rebuild table name to convert from 5.7 format to 8.0. More...

Variables
static const int	DD_FIELD_OFFSET = 2
	All DD tables would contain DB_TRX_ID and DB_ROLL_PTR fields before other fields. More...

Detailed Description

Data dictionary interface.

Function Documentation

◆ acquire_uncached_table()

int acquire_uncached_table	(	THD *	thd,
		dd::cache::Dictionary_client *	client,
		const dd::Table *	dd_table,
		const char *	name,
		TABLE_SHARE *	ts,
		TABLE *	td
	)

Open uncached table definition based on a Global DD object.

Parameters

[in]	thd	thread THD
[in]	client	data dictionary client
[in]	dd_table	Global DD table object
[in]	name	Table Name
[out]	ts	MySQL table share
[out]	td	MySQL table definition

Return values

error	number on error
0	on success

◆ copy_dropped_columns()

bool copy_dropped_columns	(	const dd::Table *	old_dd_table,
		dd::Table *	new_dd_table,
		uint32_t	current_row_version
	)

Copy metadata of already dropped columns from old table def to new table def.

param[in] old_dd_table old table definition param[in,out] new_dd_table new table definition

Return values

true	Failure
false	Success

◆ dd_add_fts_doc_id_index()

void dd_add_fts_doc_id_index	(	dd::Table &	new_table,
		const dd::Table &	old_table
	)

Add fts doc id column and index to new table when old table has hidden fts doc id without fulltext index.

Parameters

[in,out]	new_table	New dd table
[in]	old_table	Old dd table

◆ dd_add_instant_columns()

bool dd_add_instant_columns	(	const dd::Table *	old_dd_table,
		dd::Table *	new_dd_table,
		dict_table_t *	new_table,
		const Columns &	cols_to_add
	)

Add column default values for new instantly added columns.

Parameters

[in]	old_dd_table	Old dd::Table
[in,out]	new_dd_table	New dd::Table
[in,out]	new_table	New InnoDB table object
[in]	cols_to_add	columns to be added INSTANTly

Return values

true	Failure
false	Success

◆ dd_check_corrupted()

static int dd_check_corrupted ( dict_table_t *& table )

static

Check if access to a table should be refused.

Parameters

[in,out] table InnoDB table or partition

Returns: error code

Return values

0	on success (DD_SUVCCESS)

◆ dd_clear_instant_part()

void dd_clear_instant_part ( dd::Partition & dd_part )

Clear the instant ADD COLUMN information of a partition, to make it as a normal partition.

Parameters

[in,out] dd_part dd::Partition

◆ dd_clear_instant_table()

dberr_t dd_clear_instant_table	(	dd::Table &	dd_table,
		bool	clear_version
	)

Clear the instant ADD COLUMN information of a table.

Parameters

[in,out]	dd_table	dd::Table
[in]	clear_version	true if version metadata is to be cleared

Returns: DB_SUCCESS or error code

◆ dd_column_get_version_added()

uint32_t dd_column_get_version_added ( const dd::Column * dd_col )

Get the row version in which column is INSTANT ADD.

◆ dd_column_get_version_dropped()

uint32_t dd_column_get_version_dropped ( const dd::Column * dd_col )

Get the row version in which column is INSTANT DROP.

◆ dd_column_is_added()

bool dd_column_is_added ( const dd::Column * dd_col )

Determine if column is INSTANT ADD.

◆ dd_column_is_dropped()

bool dd_column_is_dropped ( const dd::Column * dd_col )

Determine if column is INSTANT DROP.

◆ dd_copy_autoinc()

void dd_copy_autoinc	(	const dd::Properties &	src,
		dd::Properties &	dest
	)

Copy the AUTO_INCREMENT and version attribute if exist.

Parameters

[in]	src	dd::Table::se_private_data to copy from
[out]	dest	dd::Table::se_private_data to copy to

◆ dd_copy_from_table_share()

void dd_copy_from_table_share	(	THD *	thd,
		dict_table_t *	table,
		const TABLE_SHARE *	table_share
	)

inline

Copy attributes from MySQL TABLE_SHARE into an InnoDB table object.

Parameters

[in,out]	thd	thread context
[in,out]	table	InnoDB table
[in]	table_share	TABLE_SHARE

◆ dd_copy_instant_n_cols()

void dd_copy_instant_n_cols	(	dd::Table &	new_table,
		const dd::Table &	old_table
	)

Copy the metadata of a table definition if there was an instant ADD COLUMN happened.

This should be done when it's not an ALTER TABLE with rebuild.

Parameters

[in,out]	new_table	New table definition
[in]	old_table	Old table definition

◆ dd_copy_private()

template<typename Table >

void dd_copy_private	(	Table &	new_table,
		const Table &	old_table
	)

Copy the engine-private parts of a table or partition definition when the change does not affect InnoDB.

This mainly copies the common private data between dd::Table and dd::Partition

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	new_table	Copy of old table or partition definition
[in]	old_table	Old table or partition definition

◆ dd_copy_private< dd::Partition >()

template void dd_copy_private< dd::Partition >	(	dd::Partition &	,
		const dd::Partition &
	)

◆ dd_copy_private< dd::Table >()

template void dd_copy_private< dd::Table >	(	dd::Table &	,
		const dd::Table &
	)

◆ dd_copy_table_columns()

void dd_copy_table_columns	(	const Alter_inplace_info *	ha_alter_info,
		dd::Table &	new_table,
		const dd::Table &	old_table,
		dict_table_t *	dict_table
	)

Copy the engine-private parts of column definitions of a table.

Parameters

[in]	ha_alter_info	alter info
[in,out]	new_table	Copy of old table
[in]	old_table	Old table
[in]	dict_table	InnoDB table cache

◆ dd_create_fts_common_table()

bool dd_create_fts_common_table	(	const dict_table_t *	parent_table,
		dict_table_t *	table,
		bool	is_config
	)

Create dd table for fts aux common table.

Parameters

[in]	parent_table	parent table of fts table
[in,out]	table	fts table
[in]	is_config	flag whether it's fts aux configure table

Returns: true on success, false on failure

◆ dd_create_fts_index_table()

bool dd_create_fts_index_table	(	const dict_table_t *	parent_table,
		dict_table_t *	table,
		const CHARSET_INFO *	charset
	)

Create dd table for fts aux index table.

Parameters

[in]	parent_table	parent table of fts table
[in,out]	table	fts table
[in]	charset	fts index charset

Returns: true on success, false on failure

◆ dd_create_implicit_tablespace()

bool dd_create_implicit_tablespace	(	dd::cache::Dictionary_client *	dd_client,
		space_id_t	space_id,
		const char *	space_name,
		const char *	filename,
		bool	discarded,
		dd::Object_id &	dd_space_id
	)

Create metadata for implicit tablespace.

Parameters

[in,out]	dd_client	data dictionary client
[in]	space_id	InnoDB tablespace ID
[in]	space_name	tablespace name to be set for the newly created tablespace
[in]	filename	tablespace filename
[in]	discarded	true if this tablespace was discarded
[in,out]	dd_space_id	dd tablespace id

Return values

false	on success
true	on failure

◆ dd_create_tablespace()

bool dd_create_tablespace	(	dd::cache::Dictionary_client *	dd_client,
		const char *	dd_space_name,
		space_id_t	space_id,
		uint32_t	flags,
		const char *	filename,
		bool	discarded,
		dd::Object_id &	dd_space_id
	)

Create metadata for specified tablespace, acquiring exclusive MDL first.

Parameters

[in,out]	dd_client	data dictionary client
[in,out]	dd_space_name	dd tablespace name
[in]	space_id	InnoDB tablespace ID
[in]	flags	InnoDB tablespace flags
[in]	filename	filename of this tablespace
[in]	discarded	true if this tablespace was discarded
[in,out]	dd_space_id	dd_space_id

Return values

false	on success
true	on failure

◆ dd_drop_fts_table()

bool dd_drop_fts_table	(	const char *	name,
		bool	file_per_table
	)

Drop dd table & tablespace for fts aux table.

Parameters

[in]	name	table name
[in]	file_per_table	flag whether use file per table

Returns: true on success, false on failure.

◆ dd_drop_instant_columns()

bool dd_drop_instant_columns	(	const dd::Table *	old_dd_table,
		dd::Table *	new_dd_table,
		dict_table_t *	new_table,
		const Columns &	cols_to_drop,
		const Columns &	cols_to_add,
		Alter_inplace_info *	ha_alter_info
	)

Drop column instantly.

It actually updates dropped columns metadata.

Parameters

[in]	old_dd_table	Old dd::Table
[in,out]	new_dd_table	New dd::Table
[in,out]	new_table	New InnoDB table objecta
[in]	cols_to_drop	list of columns to be dropped
[in]	cols_to_add	list of columns to be added
[in]	ha_alter_info	alter info

Return values

true	Failure
false	Success

◆ dd_drop_tablespace()

bool dd_drop_tablespace	(	dd::cache::Dictionary_client *	dd_client,
		dd::Object_id	dd_space_id
	)

Drop a tablespace.

Parameters

[in,out]	dd_client	data dictionary client
[in]	dd_space_id	dd tablespace id

Return values

false	On success
true	On failure

◆ dd_fill_dict_index()

int dd_fill_dict_index	(	const dd::Table &	dd_table,
		const TABLE *	m_form,
		dict_table_t *	m_table,
		THD *	m_thd
	)

inline

Instantiate index related metadata.

Parameters

[in,out]	dd_table	Global DD table metadata
[in]	m_form	MySQL table definition
[in,out]	m_table	InnoDB table definition
[in]	m_thd	THD instance

Returns: 0 if successful, otherwise error number

◆ dd_fill_dict_table()

template<typename Table >

static dict_table_t * dd_fill_dict_table	(	const Table *	dd_tab,
		const TABLE *	m_form,
		const char *	norm_name,
		HA_CREATE_INFO *	create_info,
		bool	zip_allowed,
		bool	strict,
		THD *	m_thd,
		bool	is_implicit
	)

inlinestatic

Instantiate in-memory InnoDB table metadata (dict_table_t), without any indexes.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in]	dd_tab	Global Data Dictionary metadata, or NULL for internal temporary table
[in]	m_form	MySQL TABLE for current table
[in]	norm_name	normalized table name
[in]	create_info	create info
[in]	zip_allowed	whether ROW_FORMAT=COMPRESSED is OK
[in]	strict	whether to use innodb_strict_mode=ON
[in]	m_thd	thread THD
[in]	is_implicit	if it is an implicit tablespace

Returns: created dict_table_t on success or nullptr

◆ dd_fill_instant_columns_default()

static void dd_fill_instant_columns_default	(	const dd::Table &	dd_table,
		dict_table_t *	table
	)

static

Read the metadata of default values for all columns added instantly.

Parameters

[in]	dd_table	dd::Table
[in,out]	table	InnoDB table object

◆ dd_fill_one_dict_index()

static int dd_fill_one_dict_index	(	const dd::Index *	dd_index,
		dict_table_t *	table,
		const TABLE_SHARE *	form,
		uint	key_num
	)

static

Create an index.

Parameters

[in]	dd_index	DD Index
[in,out]	table	InnoDB table
[in]	form	MySQL table structure
[in]	key_num	key_info[] offset

Returns: error code

Return values

0	on success
HA_ERR_TOO_BIG_ROW	if the record is too long

◆ dd_find_index()

template<typename Index >

const dict_index_t * dd_find_index	(	const dict_table_t *	table,
		Index *	dd_index
	)

Find the specified dd::Index or dd::Partition_index in an InnoDB table.

Template Parameters

Index dd::Index or dd::Partition_index

Parameters

[in]	table	InnoDB table object
[in]	dd_index	Index to search

Returns: the dict_index_t object related to the index

◆ dd_find_index< dd::Index >()

template const dict_index_t * dd_find_index< dd::Index >	(	const dict_table_t *	,
		dd::Index *
	)

◆ dd_find_index< dd::Partition_index >()

template const dict_index_t * dd_find_index< dd::Partition_index >	(	const dict_table_t *	,
		dd::Partition_index *
	)

◆ dd_get_and_save_data_dir_path()

template<typename Table >

void dd_get_and_save_data_dir_path	(	dict_table_t *	table,
		const Table *	dd_table,
		bool	dict_mutex_own
	)

Make sure the data_dir_path is saved in dict_table_t if DATA DIRECTORY was used.

Try to read it from the fil_system first, then from new dd.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	table	Table object
[in]	dd_table	DD table object
[in]	dict_mutex_own	true if dict_sys->mutex is owned already

◆ dd_get_and_save_data_dir_path< dd::Partition >()

template void dd_get_and_save_data_dir_path< dd::Partition >	(	dict_table_t *	,
		const dd::Partition *	,
		bool
	)

◆ dd_get_and_save_data_dir_path< dd::Table >()

template void dd_get_and_save_data_dir_path< dd::Table >	(	dict_table_t *	,
		const dd::Table *	,
		bool
	)

◆ dd_get_and_save_space_name()

template<typename Table >

void dd_get_and_save_space_name	(	dict_table_t *	table,
		const Table *	dd_table,
		bool	dict_mutex_own
	)

Make sure the tablespace name is saved in dict_table_t if the table uses a general tablespace.

Try to read it from the fil_system_t first, then from DD.

Parameters

[in]	table	Table object
[in]	dd_table	Global DD table or partition object
[in]	dict_mutex_own	true if dict_sys->mutex is owned already

◆ dd_get_and_save_space_name< dd::Partition >()

template void dd_get_and_save_space_name< dd::Partition >	(	dict_table_t *	,
		const dd::Partition *	,
		bool
	)

◆ dd_get_and_save_space_name< dd::Table >()

template void dd_get_and_save_space_name< dd::Table >	(	dict_table_t *	,
		const dd::Table *	,
		bool
	)

◆ dd_get_first_path()

template<typename Table >

char * dd_get_first_path	(	mem_heap_t *	heap,
		dict_table_t *	table,
		Table *	dd_table
	)

Get the first filepath from mysql.tablespace_datafiles for a given space_id.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	heap	heap for store file name.
[in]	table	dict table
[in]	dd_table	dd table obj

Returns: First filepath (caller must invoke ut::free() on it)

Return values

nullptr if no mysql.tablespace_datafiles entry was found.

◆ dd_get_meta_data_filename()

void dd_get_meta_data_filename	(	dict_table_t *	table,
		dd::Table *	dd_table,
		char *	filename,
		ulint	max_len
	)

Get the meta-data filename from the table name for a single-table tablespace.

Parameters

[in,out]	table	table object
[in]	dd_table	DD table object
[out]	filename	filename
[in]	max_len	filename max length

◆ dd_get_or_assign_fts_tablespace_id()

static bool dd_get_or_assign_fts_tablespace_id	(	const dict_table_t *	parent_table,
		const dict_table_t *	table,
		dd::Object_id &	dd_space_id
	)

static

Get dd tablespace id for fts table.

Parameters

[in]	parent_table	parent table of fts table
[in]	table	fts table
[in,out]	dd_space_id	dd table space id

Returns: true on success, false on failure.

◆ dd_get_referenced_table()

char * dd_get_referenced_table	(	const char *	name,
		const char *	database_name,
		ulint	database_name_len,
		const char *	table_name,
		ulint	table_name_len,
		dict_table_t **	table,
		MDL_ticket **	mdl,
		mem_heap_t *	heap
	)

Open a table from its database and table name, this is currently used by foreign constraint parser to get the referenced table.

Parameters

[in]	name	foreign key table name
[in]	database_name	table db name
[in]	database_name_len	db name length
[in]	table_name	table db name
[in]	table_name_len	table name length
[in,out]	table	table object or NULL
[in,out]	mdl	mdl on table
[in,out]	heap	heap memory

Returns: complete table name with database and table name, allocated from heap memory passed in

◆ dd_get_tablespace_size_option()

bool dd_get_tablespace_size_option	(	dd::cache::Dictionary_client *	dd_client,
		const dd::Object_id	dd_space_id,
		uint64_t *	autoextend_size
	)

Get the autoextend_size attribute for a tablespace.

Parameters

[in]	dd_client	Data dictionary client
[in]	dd_space_id	Tablespace ID
[out]	autoextend_size	Value of autoextend_size attribute

Return values

false	On success
true	On failure

◆ dd_get_total_indexes_num()

uint32_t dd_get_total_indexes_num ( )

Returns: total number of indexes of all DD tables

◆ dd_getnext_system_low()

static const rec_t * dd_getnext_system_low	(	btr_pcur_t *	pcur,
		mtr_t *	mtr
	)

static

Get next record from a new dd system table, like mysql.tables...

Parameters

[in,out]	pcur	Persistent cursor
[in]	mtr	Mini-transaction

Returns: the next rec of the dd system table

◆ dd_getnext_system_rec()

const rec_t * dd_getnext_system_rec	(	btr_pcur_t *	pcur,
		mtr_t *	mtr
	)

Get next record of new DD system tables.

Parameters

[in,out]	pcur	Persistent cursor
[in]	mtr	Mini-transaction

Return values

next record

◆ dd_implicit_alter_tablespace()

bool dd_implicit_alter_tablespace	(	dd::cache::Dictionary_client *	dd_client,
		dd::Object_id	dd_space_id,
		HA_CREATE_INFO *	create_info
	)

Set the autoextend_size attribute for an implicit tablespace.

Parameters

[in,out]	dd_client	Data dictionary client
[in]	dd_space_id	DD tablespace id
[in]	create_info	HA_CREATE_INFO object

Returns: false On success; true On failure

◆ dd_import_instant_add_columns()

void dd_import_instant_add_columns	(	const dict_table_t *	table,
		dd::Table *	dd_table
	)

Import all metadata which is related to instant ADD COLUMN of a table to dd::Table.

This is used for IMPORT.

Parameters

[in]	table	InnoDB table object
[in,out]	dd_table	dd::Table

◆ dd_index_match()

template<typename Index >

static bool dd_index_match	(	const dict_index_t *	index,
		const Index *	dd_index
	)

static

Check if the InnoDB index is consistent with dd::Index.

Parameters

[in]	index	InnoDB index
[in]	dd_index	dd::Index or dd::Partition_index

Returns: true if match

Return values

false if not match

◆ dd_instant_columns_consistent()

bool dd_instant_columns_consistent ( const dd::Table & dd_table )

Check if the instant columns are consistent with the se_private_data in dd::Table.

Parameters

[in] dd_table dd::Table

Returns: true if consistent, otherwise false

◆ dd_is_table_in_encrypted_tablespace()

bool dd_is_table_in_encrypted_tablespace ( const dict_table_t * table )

◆ dd_is_valid_row_version()

bool dd_is_valid_row_version ( uint32_t version )

Determine if give version is a valid row version.

◆ dd_load_tablespace()

template<typename Table >

void dd_load_tablespace	(	const Table *	dd_table,
		dict_table_t *	table,
		mem_heap_t *	heap,
		dict_err_ignore_t	ignore_err,
		uint32_t	expected_fsp_flags
	)

Opens a tablespace for dd_load_table_one()

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	dd_table	dd table
[in,out]	table	A table that refers to the tablespace to open
[in,out]	heap	A memory heap
[in]	expected_fsp_flags	expected flags of tablespace to be loaded
[in]	ignore_err	Whether to ignore an error.

◆ dd_match_default_value()

bool dd_match_default_value	(	const dd::Column *	dd_col,
		const dict_col_t *	col
	)

Compare the default values between imported column and column defined in the server.

Note that it's absolutely OK if there is no default value in the column defined in server, since it can be filled in later.

Parameters

[in]	dd_col	dd::Column
[in]	col	InnoDB column object

Returns: true The default values match

Return values

false Not match

◆ dd_mdl_for_undo()

bool dd_mdl_for_undo ( const trx_t & trx )

Check if current undo needs a MDL or not.

Parameters

[in] trx transaction

Returns: true if MDL is necessary, otherwise false

◆ dd_mdl_release()

void dd_mdl_release	(	THD *	thd,
		MDL_ticket **	mdl
	)

Release a metadata lock.

Parameters

[in,out]	thd	current thread
[in,out]	mdl	metadata lock

◆ dd_open_fk_tables()

void dd_open_fk_tables	(	dict_names_t &	fk_list,
		bool	dict_locked,
		THD *	thd
	)

Open foreign tables reference a table.

Parameters

[in]	fk_list	foreign key name list
[in]	dict_locked	dict_sys mutex is locked or not
[in]	thd	thread THD

◆ dd_open_table()

template<typename Table >

dict_table_t * dd_open_table	(	dd::cache::Dictionary_client *	client,
		const TABLE *	table,
		const char *	norm_name,
		const Table *	dd_table,
		THD *	thd
	)

Open or load a table definition based on a Global DD object.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	client	data dictionary client
[in]	table	MySQL table definition
[in]	norm_name	Table Name
[in]	dd_table	Global DD table or partition object
[in]	thd	thread THD

Returns: ptr to dict_table_t filled, otherwise, nullptr

◆ dd_open_table< dd::Partition >()

template dict_table_t * dd_open_table< dd::Partition >	(	dd::cache::Dictionary_client *	,
		const TABLE *	,
		const char *	,
		const dd::Partition *	,
		THD *
	)

◆ dd_open_table< dd::Table >()

template dict_table_t * dd_open_table< dd::Table >	(	dd::cache::Dictionary_client *	,
		const TABLE *	,
		const char *	,
		const dd::Table *	,
		THD *
	)

◆ dd_open_table_one()

template<typename Table >

dict_table_t * dd_open_table_one	(	dd::cache::Dictionary_client *	client,
		const TABLE *	table,
		const char *	norm_name,
		const Table *	dd_table,
		THD *	thd,
		dict_names_t &	fk_list
	)

Open or load a table definition based on a Global DD object.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	client	data dictionary client
[in]	table	MySQL table definition
[in]	norm_name	Table Name
[in]	dd_table	Global DD table or partition object
[in]	thd	thread THD
[in,out]	fk_list	stack of table names which need to load

Returns: ptr to dict_table_t filled, otherwise, nullptr

Look up the spatial reference system in the dictionary. Since this may cause a table open to read the dictionary tables, it must be done while not holding &dict_sys->mutex.

◆ dd_open_table_one_on_name()

static void dd_open_table_one_on_name	(	const char *	name,
		bool	dict_locked,
		dict_names_t &	fk_list,
		THD *	thd
	)

static

Open single table with name.

Parameters

[in]	name	table name
[in]	dict_locked	dict_sys mutex is held or not
[in,out]	fk_list	foreign key name list
[in]	thd	thread THD

◆ dd_parse_default_value()

void dd_parse_default_value	(	const dd::Properties &	se_private_data,
		dict_col_t *	col,
		mem_heap_t *	heap
	)

Parse the default value from dd::Column::se_private to dict_col_t.

Parameters

[in]	se_private_data	dd::Column::se_private
[in,out]	col	InnoDB column object
[in,out]	heap	Heap to store the default value

◆ dd_parse_merge_threshold()

static ulint dd_parse_merge_threshold	(	THD *	thd,
		const char *	str
	)

static

Parse MERGE_THRESHOLD value from a comment string.

Parameters

[in]	thd	connection
[in]	str	string which might include 'MERGE_THRESHOLD='

Returns: value parsed

Return values

dict_index_t::MERGE_THRESHOLD_DEFAULT for missing or invalid value.

◆ dd_part_adjust_table_id()

void dd_part_adjust_table_id ( dd::Table * new_table )

Adjust TABLE_ID for partitioned table after ALTER TABLE ... PARTITION.

This makes sure that the TABLE_ID stored in dd::Column::se_private_data is correct if the first partition got changed

Parameters

[in,out] new_table New dd::Table

◆ dd_process_dd_columns_rec()

bool dd_process_dd_columns_rec	(	mem_heap_t *	heap,
		const rec_t *	rec,
		dict_col_t *	col,
		table_id_t *	table_id,
		char **	col_name,
		ulint *	nth_v_col,
		const dict_table_t *	dd_columns,
		mtr_t *	mtr
	)

Process one mysql.columns record and get info to dict_col_t.

Parameters

[in,out]	heap	Temp memory heap
[in]	rec	mysql.columns record
[in,out]	col	dict_col_t to fill
[in,out]	table_id	Table id
[in,out]	col_name	Column name
[in,out]	nth_v_col	Nth v column
[in]	dd_columns	dict_table_t obj of mysql.columns
[in,out]	mtr	Mini-transaction

Return values

true	if column is filled

◆ dd_process_dd_indexes_rec()

bool dd_process_dd_indexes_rec	(	mem_heap_t *	heap,
		const rec_t *	rec,
		const dict_index_t **	index,
		MDL_ticket **	mdl,
		dict_table_t **	parent,
		MDL_ticket **	parent_mdl,
		dict_table_t *	dd_indexes,
		mtr_t *	mtr
	)

Process one mysql.indexes record and get the dict_index_t.

Parameters

[in]	heap	Temp memory heap
[in,out]	rec	mysql.indexes record
[in,out]	index	dict_index_t to fill
[in]	mdl	MDL on index->table
[in,out]	parent	Parent table if it's fts aux table.
[in,out]	parent_mdl	MDL on parent if it's fts aux table.
[in]	dd_indexes	dict_table_t obj of mysql.indexes
[in]	mtr	Mini-transaction

Return values

true	if index is filled

◆ dd_process_dd_indexes_rec_simple()

bool dd_process_dd_indexes_rec_simple	(	mem_heap_t *	heap,
		const rec_t *	rec,
		space_index_t *	index_id,
		space_id_t *	space_id,
		dict_table_t *	dd_indexes
	)

Process one mysql.indexes record and get brief info to dict_index_t.

Parameters

[in]	heap	temp memory heap
[in,out]	rec	mysql.indexes record
[in,out]	index_id	index id
[in,out]	space_id	space id
[in]	dd_indexes	dict_table_t obj of mysql.indexes

Return values

true	if index is filled

◆ dd_process_dd_partitions_rec_and_mtr_commit()

const char * dd_process_dd_partitions_rec_and_mtr_commit	(	mem_heap_t *	heap,
		const rec_t *	rec,
		dict_table_t **	table,
		dict_table_t *	dd_tables,
		MDL_ticket **	mdl,
		mtr_t *	mtr
	)

Process one mysql.table_partitions record and get the dict_table_t.

Parameters

[in]	heap	Temp memory heap
[in,out]	rec	mysql.table_partitions record
[in,out]	table	dict_table_t to fill
[in]	dd_tables	dict_table_t obj of dd partition table
[in]	mdl	MDL on the table
[in]	mtr	Mini-transaction

Return values

error message, or NULL on success

◆ dd_process_dd_tables_rec_and_mtr_commit()

const char * dd_process_dd_tables_rec_and_mtr_commit	(	mem_heap_t *	heap,
		const rec_t *	rec,
		dict_table_t **	table,
		dict_table_t *	dd_tables,
		MDL_ticket **	mdl,
		mtr_t *	mtr
	)

Process one mysql.tables record and get the dict_table_t.

Parameters

[in]	heap	Temp memory heap
[in,out]	rec	mysql.tables record
[in,out]	table	dict_table_t to fill
[in]	dd_tables	dict_table_t obj of dd system table
[in]	mdl	MDL on the table
[in]	mtr	Mini-transaction

Return values

error message, or NULL on success

◆ dd_process_dd_tablespaces_rec()

bool dd_process_dd_tablespaces_rec	(	mem_heap_t *	heap,
		const rec_t *	rec,
		space_id_t *	space_id,
		char **	name,
		uint32_t *	flags,
		uint32_t *	server_version,
		uint32_t *	space_version,
		bool *	is_encrypted,
		uint64_t *	autoextend_size,
		dd::String_type *	state,
		dict_table_t *	dd_spaces
	)

Process one mysql.tablespaces record and get info.

Parameters

[in]	heap	temp memory heap
[in]	rec	mysql.tablespaces record
[out]	space_id	space id
[out]	name	space name
[out]	flags	space flags
[out]	server_version	server version
[out]	space_version	space version
[out]	is_encrypted	true if tablespace is encrypted
[out]	autoextend_size	autoextend_size attribute value
[out]	state	space state
[in]	dd_spaces	dict_table_t obj of mysql.tablespaces

Returns: true if data is retrieved

◆ dd_process_dd_virtual_columns_rec()

bool dd_process_dd_virtual_columns_rec	(	mem_heap_t *	heap,
		const rec_t *	rec,
		table_id_t *	table_id,
		ulint **	pos,
		ulint **	base_pos,
		ulint *	n_row,
		dict_table_t *	dd_columns,
		mtr_t *	mtr
	)

Process one mysql.columns record for virtual columns.

Parameters

[in]	heap	temp memory heap
[in,out]	rec	mysql.columns record
[in,out]	table_id	Table id
[in,out]	pos	Position
[in,out]	base_pos	Base column position
[in,out]	n_row	Number of rows
[in]	dd_columns	dict_table_t obj of mysql.columns
[in]	mtr	Mini-transaction

Return values

true	if virtual info is filled

◆ dd_release_mdl()

void dd_release_mdl ( MDL_ticket * mdl_ticket )

Release the MDL held by the given ticket.

Parameters

[in] mdl_ticket tablespace MDL ticket

◆ dd_rename_fts_table()

bool dd_rename_fts_table	(	const dict_table_t *	table,
		const char *	old_name
	)

Rename dd table & tablespace files for fts aux table.

Parameters

[in]	table	dict table
[in]	old_name	old innodb table name

Returns: true on success, false on failure.

◆ dd_set_autoinc()

void dd_set_autoinc	(	dd::Properties &	se_private_data,
		uint64_t	autoinc
	)

Set the AUTO_INCREMENT attribute.

Parameters

[in,out]	se_private_data	dd::Table::se_private_data
[in]	autoinc	the auto-increment value

◆ dd_set_discarded() [1/2]

void dd_set_discarded	(	dd::Partition &	partition,
		bool	discard
	)

Sets appropriate discard attribute of dd::Partition Please note that this function can be only called on leaf_partitions.

Parameters

[in]	partition	leaf dd::Partition
[in]	discard	true if Table is discarded, false otherwise

◆ dd_set_discarded() [2/2]

void dd_set_discarded	(	dd::Table &	table,
		bool	discard
	)

Sets appropriate discard attribute of dd::Table Please note that this function must not be called on partitioned tables.

Parameters

[in]	table	non-partitioned dd::Table
[in]	discard	true if Table is discarded, false otherwise

◆ dd_set_fts_nullability()

static void dd_set_fts_nullability	(	dd::Column *	dd_col,
		const dict_col_t *	col
	)

static

Add nullability info to column se_private_data.

Parameters

[in,out]	dd_col	DD table column
[in]	col	InnoDB table column

◆ dd_set_fts_table_options()

void dd_set_fts_table_options	(	dd::Table *	dd_table,
		const dict_table_t *	table
	)

Set table options for fts dd tables according to dict table.

Parameters

[in,out]	dd_table	dd table instance
[in]	table	dict table instance

◆ dd_set_table_options()

template<typename Table >

void dd_set_table_options	(	Table *	dd_table,
		const dict_table_t *	table
	)

Set options of dd::Table according to InnoDB table object.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	dd_table	dd::Table or dd::Partition
[in]	table	InnoDB table object

◆ dd_set_table_options< dd::Partition >()

template void dd_set_table_options< dd::Partition >	(	dd::Partition *	,
		const dict_table_t *
	)

◆ dd_set_table_options< dd::Table >()

template void dd_set_table_options< dd::Table >	(	dd::Table *	,
		const dict_table_t *
	)

◆ dd_set_tablespace_compression()

bool dd_set_tablespace_compression	(	dd::cache::Dictionary_client *	client,
		const char *	algorithm,
		dd::Object_id	dd_space_id
	)

Set Innodb tablespace compression option from DD.

Parameters

[in,out]	client	dictionary client
[in]	algorithm	compression algorithm
[in]	dd_space_id	DD tablespace ID.

Returns: true, if failed to set compression.

◆ dd_space_get_name()

template<typename Table >

char * dd_space_get_name	(	mem_heap_t *	heap,
		dict_table_t *	table,
		Table *	dd_table
	)

Get the space name from mysql.tablespaces for a given space_id.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in,out]	heap	heap for store file name.
[in]	table	dict table
[in]	dd_table	dd table obj

Returns: First filepath (caller must invoke ut::free() on it)

Return values

nullptr if no mysql.tablespace_datafiles entry was found.

◆ dd_startscan_system()

const rec_t * dd_startscan_system	(	THD *	thd,
		MDL_ticket **	mdl,
		btr_pcur_t *	pcur,
		mtr_t *	mtr,
		const char *	system_table_name,
		dict_table_t **	table
	)

Scan a new dd system table, like mysql.tables...

Parameters

[in]	thd	THD
[in,out]	mdl	MDL lock
[in,out]	pcur	Persistent cursor
[in,out]	mtr	Mini-transaction
[in]	system_table_name	Which dd system table to open
[in,out]	table	dict_table_t obj of dd system table

Return values

the	first rec of the dd system table

◆ dd_table_check_for_child()

dberr_t dd_table_check_for_child	(	dd::cache::Dictionary_client *	client,
		const char *	tbl_name,
		const char **	col_names,
		dict_table_t *	m_table,
		bool	check_charsets,
		dict_err_ignore_t	ignore_err,
		dict_names_t *	fk_tables
	)

Load foreign key constraint for the table.

Note, it could also open the foreign table, if this table is referenced by the foreign table

Parameters

[in,out]	client	data dictionary client
[in]	tbl_name	Table Name
[in]	col_names	column names, or NULL
[out]	m_table	InnoDB table handle
[in]	check_charsets	whether to check charset compatibility
[in]	ignore_err	DICT_ERR_IGNORE_FK_NOKEY or DICT_ERR_IGNORE_NONE
[in,out]	fk_tables	name list for tables that refer to this table

Returns: DB_SUCCESS if successfully load FK constraint

◆ dd_table_close()

void dd_table_close	(	dict_table_t *	table,
		THD *	thd,
		MDL_ticket **	mdl,
		bool	dict_locked
	)

Close an internal InnoDB table handle.

Parameters

[in,out]	table	InnoDB table handle
[in,out]	thd	current MySQL connection (for mdl)
[in,out]	mdl	metadata lock (will be set NULL)
[in]	dict_locked	whether we hold dict_sys mutex

◆ dd_table_contains_fulltext()

bool dd_table_contains_fulltext ( const dd::Table & table )

inline

Determine if a table contains a fulltext index.

Parameters

[in] table dd::Table

Returns: whether the table contains any fulltext index

◆ dd_table_discard_tablespace()

bool dd_table_discard_tablespace	(	THD *	thd,
		const dict_table_t *	table,
		dd::Table *	table_def,
		bool	discard
	)

Set the discard flag for a non-partitioned dd table.

Parameters

[in,out]	thd	current thread
[in]	table	InnoDB table
[in,out]	table_def	MySQL dd::Table to update
[in]	discard	discard flag

Returns: true if success

Return values

false if fail.

◆ dd_table_get_space_name()

template<typename Table >

const char * dd_table_get_space_name ( const Table * dd_table )

Get tablespace name of dd::Table.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in] dd_table dd table object

Returns: the tablespace name or nullptr if failed

◆ dd_table_load_fk()

dberr_t dd_table_load_fk	(	dd::cache::Dictionary_client *	client,
		const char *	tbl_name,
		const char **	col_names,
		dict_table_t *	m_table,
		const dd::Table *	dd_table,
		THD *	thd,
		bool	dict_locked,
		bool	check_charsets,
		dict_names_t *	fk_tables
	)

Load foreign key constraint for the table.

Note, it could also open the foreign table, if this table is referenced by the foreign table

Parameters

[in,out]	client	data dictionary client
[in]	tbl_name	Table Name
[in]	col_names	column names, or NULL
[out]	m_table	InnoDB table handle
[in]	dd_table	Global DD table
[in]	thd	thread THD
[in]	dict_locked	True if dict_sys->mutex is already held, otherwise false
[in]	check_charsets	whether to check charset compatibility
[in,out]	fk_tables	name list for tables that refer to this table

Returns: DB_SUCCESS if successfully load FK constraint

◆ dd_table_load_fk_from_dd()

dberr_t dd_table_load_fk_from_dd	(	dict_table_t *	m_table,
		const dd::Table *	dd_table,
		const char **	col_names,
		dict_err_ignore_t	ignore_err,
		bool	dict_locked
	)

Load foreign key constraint info for the dd::Table object.

Parameters

[out]	m_table	InnoDB table handle
[in]	dd_table	Global DD table
[in]	col_names	column names, or NULL
[in]	ignore_err	DICT_ERR_IGNORE_FK_NOKEY or DICT_ERR_IGNORE_NONE
[in]	dict_locked	True if dict_sys->mutex is already held, otherwise false

Returns: DB_SUCCESS if successfully load FK constraint

◆ dd_table_match()

template<typename Table >

bool dd_table_match	(	const dict_table_t *	table,
		const Table *	dd_table
	)

Check if the InnoDB table is consistent with dd::Table.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in]	table	InnoDB table
[in]	dd_table	dd::Table or dd::Partition

Returns: true if match

Return values

false if not match

◆ dd_table_match< dd::Partition >()

template bool dd_table_match< dd::Partition >	(	const dict_table_t *	,
		const dd::Partition *
	)

◆ dd_table_match< dd::Table >()

template bool dd_table_match< dd::Table >	(	const dict_table_t *	,
		const dd::Table *
	)

◆ dd_table_open_on_dd_obj()

int dd_table_open_on_dd_obj	(	THD *	thd,
		dd::cache::Dictionary_client *	client,
		const dd::Table &	dd_table,
		const dd::Partition *	dd_part,
		const char *	tbl_name,
		dict_table_t *&	table,
		const TABLE *	td
	)

Instantiate an InnoDB in-memory table metadata (dict_table_t) based on a Global DD object or MYSQL table definition.

Parameters

[in]	thd	thread THD
[in,out]	client	data dictionary client
[in]	dd_table	Global DD table object
[in]	dd_part	Global DD partition or subpartition, or NULL
[in]	tbl_name	table name, or NULL if not known
[out]	table	InnoDB table (NULL if not found or loadable)
[in]	td	MYSQL table definition

Returns: error code

Return values

0	on success

◆ dd_table_open_on_id()

dict_table_t * dd_table_open_on_id	(	table_id_t	table_id,
		THD *	thd,
		MDL_ticket **	mdl,
		bool	dict_locked,
		bool	check_corruption
	)

Open a persistent InnoDB table based on InnoDB table id, and hold Shared MDL lock on it.

Parameters

[in]	table_id	table identifier
[in,out]	thd	current MySQL connection (for mdl)
[in,out]	mdl	metadata lock (*mdl set if table_id was found) mdl=NULL if we are resurrecting table IX locks in recovery
[in]	dict_locked	dict_sys mutex is held
[in]	check_corruption	check if the table is corrupted or not.

Returns: table

Return values

NULL	if the table does not exist or cannot be opened

◆ dd_table_open_on_id_low()

static dict_table_t * dd_table_open_on_id_low	(	THD *	thd,
		MDL_ticket **	mdl,
		table_id_t	table_id
	)

static

Load an InnoDB table definition by InnoDB table ID.

Parameters

[in,out]	thd	current thread
[in,out]	mdl	metadata lock; nullptr if we are resurrecting table IX locks in recovery
[in]	table_id	InnoDB table or partition ID

Returns: InnoDB table

Return values

nullptr if the table is not found, or there was an error

◆ dd_table_open_on_name()

dict_table_t * dd_table_open_on_name	(	THD *	thd,
		MDL_ticket **	mdl,
		const char *	name,
		bool	dict_locked,
		ulint	ignore_err,
		int *	error
	)

Open an internal handle to a persistent InnoDB table by name.

Parameters

[in,out]	thd	current thread
[out]	mdl	metadata lock
[in]	name	InnoDB table name
[in]	dict_locked	has dict_sys mutex locked
[in]	ignore_err	whether to ignore err
[out]	error	pointer to error

Returns: handle to non-partitioned table

Return values

NULL	if the table does not exist

◆ dd_tablespace_get_mdl()

bool dd_tablespace_get_mdl	(	const char *	space_name,
		MDL_ticket **	mdl_ticket = `nullptr`,
		bool	foreground = `true`
	)

Get the MDL for the named tablespace.

The mdl_ticket pointer can be provided if it is needed by the caller. If foreground is set to false, then the caller must explicitly release that ticket with dd_release_mdl(). Otherwise, it will ne released with the transaction.

Parameters

[in]	space_name	tablespace name
[in]	mdl_ticket	tablespace MDL ticket, default to nullptr
[in]	foreground	true, if the caller is foreground thread. Default is true. For foreground, the lock duration is MDL_TRANSACTION. Otherwise, it is MDL_EXPLICIT.

Returns: DD_SUCCESS or DD_FAILURE.

◆ dd_tablespace_get_state() [1/2]

void dd_tablespace_get_state	(	const dd::Properties *	p,
		dd::String_type *	state,
		space_id_t	space_id = `SPACE_UNKNOWN`
	)

Get state attribute value in dd::Tablespace::se_private_data.

Parameters

[in]	p	dd::Properties for dd::Tablespace::se_private_data
[in,out]	state	tablespace state attribute
[in]	space_id	tablespace ID

◆ dd_tablespace_get_state() [2/2]

void dd_tablespace_get_state	(	const dd::Tablespace *	dd_space,
		dd::String_type *	state,
		space_id_t	space_id = `SPACE_UNKNOWN`
	)

Get state attribute value in dd::Tablespace::se_private_data.

Parameters

[in]	dd_space	dd::Tablespace object
[in,out]	state	tablespace state attribute
[in]	space_id	tablespace ID

◆ dd_tablespace_get_state_enum() [1/2]

dd_space_states dd_tablespace_get_state_enum	(	const dd::Properties *	p,
		space_id_t	space_id = `SPACE_UNKNOWN`
	)

Get the enum for the state of a tablespace from either dd::Tablespace::se_private_data or undo::Tablespace.

Parameters

[in]	p	dd::Properties for dd::Tablespace::se_private_data
[in]	space_id	tablespace ID

Returns: enumerated value associated with the key 'state'

◆ dd_tablespace_get_state_enum() [2/2]

dd_space_states dd_tablespace_get_state_enum	(	const dd::Tablespace *	dd_space,
		space_id_t	space_id = `SPACE_UNKNOWN`
	)

Get the enum for the state of the undo tablespace from either dd::Tablespace::se_private_data or undo::Tablespace.

Parameters

[in]	dd_space	dd::Tablespace object
[in]	space_id	tablespace ID

Returns: enumerated value associated with the key 'state'

◆ dd_tablespace_get_state_enum_legacy()

dd_space_states dd_tablespace_get_state_enum_legacy	(	const dd::Properties *	p,
		space_id_t	space_id = `SPACE_UNKNOWN`
	)

Get the enum for the state of a tablespace.

Try the old 'discarded' key value for IBD spaces or undo::Tablespace.

Parameters

[in]	p	dd::Properties for dd::Tablespace::se_private_data
[in]	space_id	tablespace ID

Returns: enumerated value associated with the key 'state'

◆ dd_tablespace_is_discarded()

bool dd_tablespace_is_discarded ( const dd::Tablespace * dd_space )

Get the discarded state from se_private_data of tablespace.

Parameters

[in] dd_space dd::Tablespace object

◆ dd_tablespace_is_implicit()

bool dd_tablespace_is_implicit	(	const dd::Tablespace *	dd_space,
		bool *	implicit
	)

Determine if a tablespace is implicit.

Parameters

[in]	dd_space	DD space object
[out]	implicit	whether the tablespace is implicit tablespace

Return values

false	on success
true	on failure (corrupt tablespace object).

◆ dd_tablespace_rename()

dberr_t dd_tablespace_rename	(	dd::Object_id	dd_space_id,
		bool	is_system_cs,
		const char *	new_space_name,
		const char *	new_path
	)

Update the tablespace name and file name for rename operation.

Parameters

[in]	dd_space_id	dd tablespace id
[in]	is_system_cs	true, if space name is in system characters set. While renaming during bootstrap we have it in system cs. Otherwise, in file system cs.
[in]	new_space_name	dd_tablespace name
[in]	new_path	new data file path

Return values

DB_SUCCESS on success.

◆ dd_tablespace_set_id_and_state()

bool dd_tablespace_set_id_and_state	(	const char *	space_name,
		space_id_t	space_id,
		dd_space_states	state
	)

Set Space ID and state attribute in se_private_data of mysql.tablespaces for the named tablespace.

Parameters

[in]	space_name	tablespace name
[in]	space_id	tablespace id
[in]	state	value to set for key 'state'

Returns: DB_SUCCESS or DD_FAILURE.

◆ dd_tablespace_set_space_id()

void dd_tablespace_set_space_id	(	dd::Tablespace *	dd_space,
		space_id_t	space_id
	)

Set the space_id attribute in se_private_data of tablespace.

Parameters

[in,out]	dd_space	dd::Tablespace object
[in]	space_id	tablespace ID

◆ dd_tablespace_set_state() [1/2]

void dd_tablespace_set_state	(	dd::Tablespace *	dd_space,
		dd_space_states	state
	)

Set the 'state' value in dd:tablespace::se_private_data.

The caller will update the transaction.

Parameters

[in,out]	dd_space	dd::Tablespace object
[in]	state	value to set for key 'state'

◆ dd_tablespace_set_state() [2/2]

void dd_tablespace_set_state	(	THD *	thd,
		dd::Object_id	dd_space_id,
		std::string	space_name,
		dd_space_states	state
	)

Set the 'state' value in dd:tablespace::se_private_data starting with an object id and the space name.

Update the transaction when complete.

Parameters

[in]	thd	current thread
[in]	dd_space_id	dd::Tablespace
[in]	space_name	tablespace name
[in]	state	value to set for key 'state'.

◆ dd_tablespace_update_cache()

bool dd_tablespace_update_cache ( THD * thd )

Update all InnoDB tablespace cache objects.

This step is done post dictionary trx rollback, binlog recovery and DDL_LOG apply. So DD is consistent. Update the cached tablespace objects, if they differ from the dictionary.

Parameters

[in,out] thd thread handle

Return values

true	on error
false	on success

◆ dd_thd_for_undo()

THD * dd_thd_for_undo ( const trx_t & trx )

Returns thd associated with the trx or current_thd.

Parameters

[in] trx transaction

Returns: trx->mysql_thd or current_thd

◆ dd_update_table_and_partitions_after_dir_change()

dberr_t dd_update_table_and_partitions_after_dir_change	(	dd::Object_id	object_id,
		std::string	path
	)

Update the data directory flag in dd::Table key strings.

Parameters

[in]	object_id	dd tablespace object id
[in]	path	path where the ibd file is located currently

Return values

DB_SUCCESS on success.

◆ dd_update_v_cols()

void dd_update_v_cols	(	dd::Table *	dd_table,
		table_id_t	id
	)

Update virtual columns with new se_private_data, currently, only table_id is set.

Parameters

[in,out]	dd_table	dd::Table
[in]	id	InnoDB table ID to set

◆ dd_visit_keys_with_too_long_parts()

void dd_visit_keys_with_too_long_parts	(	const TABLE *	table,
		const size_t	max_part_len,
		std::function< void(const KEY &)>	visitor
	)

Scan through all the keys to identify the key parts which are greater than the maximum size supported by the table record format.

Parameters

table	MySQL table definition.
max_part_len	Maximum index part length allowed.
visitor	Function wrapper to invoke lambda expression.

◆ dd_write_default_value()

void dd_write_default_value	(	const dict_col_t *	col,
		dd::Column *	dd_col
	)

Write default value of a column to dd::Column.

Parameters

[in]	col	default value of this column to write
[in,out]	dd_col	where to store the default value

◆ dd_write_index()

template<typename Index >

static void dd_write_index	(	dd::Object_id	dd_space_id,
		Index *	dd_index,
		const dict_index_t *	index
	)

static

Write metadata of a index to dd::Index.

Parameters

[in]	dd_space_id	Tablespace id, which server allocates
[in,out]	dd_index	dd::Index
[in]	index	InnoDB index object

◆ dd_write_index< dd::Index >()

template void dd_write_index< dd::Index >	(	dd::Object_id	,
		dd::Index *	,
		const dict_index_t *
	)

◆ dd_write_index< dd::Partition_index >()

template void dd_write_index< dd::Partition_index >	(	dd::Object_id	,
		dd::Partition_index *	,
		const dict_index_t *
	)

◆ dd_write_table()

template<typename Table >

void dd_write_table	(	dd::Object_id	dd_space_id,
		Table *	dd_table,
		const dict_table_t *	table
	)

Write metadata of a table to dd::Table.

Template Parameters

Table dd::Table or dd::Partition

Parameters

[in]	dd_space_id	Tablespace id, which server allocates
[in,out]	dd_table	dd::Table or dd::Partition
[in]	table	InnoDB table object

◆ dd_write_table< dd::Partition >()

template void dd_write_table< dd::Partition >	(	dd::Object_id	,
		dd::Partition *	,
		const dict_table_t *
	)

◆ dd_write_table< dd::Table >()

template void dd_write_table< dd::Table >	(	dd::Object_id	,
		dd::Table *	,
		const dict_table_t *
	)

◆ dd_write_tablespace()

void dd_write_tablespace	(	dd::Tablespace *	dd_space,
		space_id_t	space_id,
		uint32_t	fsp_flags,
		dd_space_states	state
	)

Write metadata of a tablespace to dd::Tablespace.

Parameters

[in,out]	dd_space	dd::Tablespace
[in]	space_id	InnoDB tablespace ID
[in]	fsp_flags	InnoDB tablespace flags
[in]	state	InnoDB tablespace state

◆ fill_dict_columns()

template<typename Table >

static void fill_dict_columns	(	const Table *	dd_table,
		const TABLE *	m_form,
		dict_table_t *	dict_table,
		const unsigned	n_mysql_cols,
		mem_heap_t *	heap,
		bool	add_doc_id
	)

inlinestatic

◆ fill_dict_dropped_column()

static void fill_dict_dropped_column	(	const dd::Column *	column,
		dict_table_t *	dict_table,
		uint32_t &	crv,
		mem_heap_t *	heap
	)

static

◆ fill_dict_dropped_columns()

void fill_dict_dropped_columns	(	const dd::Table *	dd_table,
		dict_table_t *	dict_table,
		uint32_t &	current_row_version,
		mem_heap_t *	heap
	)

Add definition of INSTANT dropped column in table cache.

Parameters

[in]	dd_table	Table definition
[in,out]	dict_table	Table cache
[out]	current_row_version	row_version
[in]	heap	heap

◆ fill_dict_existing_column()

template<typename Table >

static void fill_dict_existing_column	(	const Table *	dd_tab,
		const TABLE *	m_form,
		dict_table_t *	m_table,
		uint32_t &	crv,
		mem_heap_t *	heap,
		const uint32_t	pos,
		bool	has_row_versions
	)

inlinestatic

◆ format_validate()

static bool format_validate	(	THD *	thd,
		const TABLE *	form,
		row_type	real_type,
		bool	zip_allowed,
		bool	strict,
		bool *	is_redundant,
		bool *	blob_prefix,
		ulint *	zip_ssize,
		bool	is_implicit
	)

static

Validate the table format options.

Parameters

[in]	thd	THD instance
[in]	form	MySQL table definition
[in]	real_type	real row type if it's not ROW_TYPE_NOT_USED
[in]	zip_allowed	whether ROW_FORMAT=COMPRESSED is OK
[in]	strict	whether innodb_strict_mode=ON
[out]	is_redundant	whether ROW_FORMAT=REDUNDANT
[out]	blob_prefix	whether ROW_FORMAT=DYNAMIC or ROW_FORMAT=COMPRESSED
[out]	zip_ssize	log2(compressed page size), or 0 if not ROW_FORMAT=COMPRESSED
[out]	is_implicit	if tablespace is implicit

Return values

true	if invalid (my_error will have been called)
false	if valid

◆ get_field_types()

void get_field_types	(	const dd::Table *	dd_tab,
		const dict_table_t *	m_table,
		const Field *	field,
		unsigned &	col_len,
		ulint &	mtype,
		ulint &	prtype
	)

Get the mtype, prtype and len for a field.

Parameters

[in]	dd_tab	dd table definition
[in]	m_table	innodb table cache
[in]	field	MySQL field
[out]	col_len	length
[out]	mtype	mtype
[out]	prtype	prtype

◆ get_index_prefix_len()

static uint16_t get_index_prefix_len	(	const KEY &	key,
		const KEY_PART_INFO *	key_part
	)

inlinestatic

Return the prefix length of the key.

Parameters

[in]	key	Key information.
[in]	key_part	Key part information.

Returns: Key prefix length or 0 if whole column is indexed.

◆ instant_update_table_cols_count()

static void instant_update_table_cols_count	(	dict_table_t *	dict_table,
		uint32_t	n_added_column,
		uint32_t	n_dropped_column
	)

static

◆ is_dropped()

bool is_dropped	(	const Alter_inplace_info *	ha_alter_info,
		const char *	column_name
	)

Check if given column is dropped during ALTER.

Parameters

[in]	ha_alter_info	alter info
[in]	column_name	Column name

Returns: true if column is dropped, false otherwise.

◆ is_renamed()

bool is_renamed	(	const Alter_inplace_info *	ha_alter_info,
		const char *	old_name,
		std::string &	new_name
	)

Check if given column is renamed during ALTER.

Parameters

[in]	ha_alter_info	alter info
[in]	old_name	column old name
[out]	new_name	column new name

Returns: true if column is renamed, false otherwise.

◆ release_uncached_table()

void release_uncached_table	(	TABLE_SHARE *	ts,
		TABLE *	td
	)

free uncached table definition.

Parameters

[in]	ts	MySQL table share
[in]	td	MySQL table definition

◆ replace_space_name_in_file_name()

static void replace_space_name_in_file_name	(	dd::Tablespace_file *	dd_file,
		dd::String_type	new_space_name
	)

static

Replace the tablespace name in the file name.

Parameters

[in]	dd_file	the tablespace file object.
[in]	new_space_name	new table space name to be updated in file name. It must have already been converted to the filename_charset such that `d1/d2\d3`.`t3\t4/t5` should look like: d1@002fd2@005cd3/t3@005ct4@002ft5 both on Windows and on Linux.

◆ set_dropped_column_name()

static void set_dropped_column_name	(	std::string &	name,
		uint32_t	version,
		uint32_t	phy_pos
	)

static

◆ to_lower()

static void to_lower ( std::string & name )

static

Convert string to lower case.

Parameters

[in,out] name name to convert

◆ validate_dropped_col_metadata()

static void validate_dropped_col_metadata	(	const dd::Table *	dd_table,
		const dict_table_t *	table
	)

inlinestatic

◆ validate_index_len()

static void validate_index_len	(	dict_table_t *	m_table,
		const TABLE *	table
	)

static

Check if the individual parts of the composite index does not exceed the limit based on the table row format.

If yes, mark the index as corrupt.

Parameters

[in]	m_table	InnoDB table handle
[in]	table	MySQL table definition

Variable Documentation

◆ DD_FIELD_OFFSET

const int DD_FIELD_OFFSET = 2

static

All DD tables would contain DB_TRX_ID and DB_ROLL_PTR fields before other fields.

This offset indicates the position at which the first DD column is located.

Namespaces

Functions

Variables

Detailed Description

Function Documentation

◆ acquire_uncached_table()

◆ copy_dropped_columns()

◆ dd_add_fts_doc_id_index()

◆ dd_add_instant_columns()

◆ dd_check_corrupted()

◆ dd_clear_instant_part()

◆ dd_clear_instant_table()

◆ dd_column_get_version_added()

◆ dd_column_get_version_dropped()

◆ dd_column_is_added()

◆ dd_column_is_dropped()

◆ dd_copy_autoinc()

◆ dd_copy_from_table_share()

◆ dd_copy_instant_n_cols()

◆ dd_copy_private()

◆ dd_copy_private< dd::Partition >()

◆ dd_copy_private< dd::Table >()

◆ dd_copy_table_columns()

◆ dd_create_fts_common_table()

◆ dd_create_fts_index_table()

◆ dd_create_implicit_tablespace()

◆ dd_create_tablespace()

◆ dd_drop_fts_table()

◆ dd_drop_instant_columns()

◆ dd_drop_tablespace()

◆ dd_fill_dict_index()

◆ dd_fill_dict_table()

◆ dd_fill_instant_columns_default()

◆ dd_fill_one_dict_index()

◆ dd_find_index()

◆ dd_find_index< dd::Index >()

◆ dd_find_index< dd::Partition_index >()

◆ dd_get_and_save_data_dir_path()

◆ dd_get_and_save_data_dir_path< dd::Partition >()

◆ dd_get_and_save_data_dir_path< dd::Table >()

◆ dd_get_and_save_space_name()

◆ dd_get_and_save_space_name< dd::Partition >()

◆ dd_get_and_save_space_name< dd::Table >()

◆ dd_get_first_path()

◆ dd_get_meta_data_filename()

◆ dd_get_or_assign_fts_tablespace_id()

◆ dd_get_referenced_table()

◆ dd_get_tablespace_size_option()

◆ dd_get_total_indexes_num()

◆ dd_getnext_system_low()

◆ dd_getnext_system_rec()

◆ dd_implicit_alter_tablespace()

◆ dd_import_instant_add_columns()

◆ dd_index_match()

◆ dd_instant_columns_consistent()

◆ dd_is_table_in_encrypted_tablespace()

◆ dd_is_valid_row_version()

◆ dd_load_tablespace()

◆ dd_match_default_value()

◆ dd_mdl_for_undo()

◆ dd_mdl_release()

◆ dd_open_fk_tables()

◆ dd_open_table()

◆ dd_open_table< dd::Partition >()

◆ dd_open_table< dd::Table >()

◆ dd_open_table_one()

◆ dd_open_table_one_on_name()

◆ dd_parse_default_value()

◆ dd_parse_merge_threshold()

◆ dd_part_adjust_table_id()

◆ dd_process_dd_columns_rec()

◆ dd_process_dd_indexes_rec()

◆ dd_process_dd_indexes_rec_simple()

◆ dd_process_dd_partitions_rec_and_mtr_commit()

◆ dd_process_dd_tables_rec_and_mtr_commit()

◆ dd_process_dd_tablespaces_rec()

◆ dd_process_dd_virtual_columns_rec()

◆ dd_release_mdl()

◆ dd_rename_fts_table()

◆ dd_set_autoinc()