Loads to the memory cache database object definitions from dictionary tables. More...

#include "current_thd.h"
#include "ha_prototypes.h"
#include <set>
#include <stack>
#include "dict0load.h"
#include "btr0btr.h"
#include "btr0pcur.h"
#include "dict0boot.h"
#include "dict0crea.h"
#include "dict0dd.h"
#include "dict0dict.h"
#include "dict0mem.h"
#include "dict0priv.h"
#include "dict0stats.h"
#include "fsp0file.h"
#include "fsp0sysspace.h"
#include "fts0priv.h"
#include "mach0data.h"
#include "my_dbug.h"
#include "fil0fil.h"
#include "fts0fts.h"
#include "mysql_version.h"
#include "page0page.h"
#include "rem0cmp.h"
#include "srv0srv.h"
#include "srv0start.h"

Functions
static bool	dict_load_is_system_table (const char *name)
	This variant is based on name comparison and is used because system table id array is not built yet. More...

static dict_table_t *	dict_load_table_one (table_name_t &name, bool cached, dict_err_ignore_t ignore_err, dict_names_t &fk_tables, const std::string *prev_table)
	Loads a table definition and also all its index definitions. More...

static const char *	dict_load_table_low (table_name_t &name, const rec_t rec, dict_table_t *table)
	Loads a table definition from a SYS_TABLES record to dict_table_t. More...

static bool	name_of_col_is (const dict_table_t table, const dict_index_t index, ulint i, const char *name)
	Compare the name of an index column. More...

char *	dict_get_first_table_name_in_db (const char *name)
	Finds the first table name in the given database. More...

static const rec_t *	dict_getnext_system_low (btr_pcur_t pcur, mtr_t mtr)
	This function gets the next system table record as it scans the table. More...

const rec_t *	dict_startscan_system (btr_pcur_t pcur, mtr_t mtr, dict_system_id_t system_id)
	This function opens a system table, and returns the first record. More...

const rec_t *	dict_getnext_system (btr_pcur_t pcur, mtr_t mtr)
	This function gets the next system table record as it scans the table. More...

static const char *	dict_load_index_low (byte table_id, const char table_name, mem_heap_t heap, const rec_t rec, bool allocate, dict_index_t **index)
	Load an index definition from a SYS_INDEXES record to dict_index_t. More...

static const char *	dict_load_column_low (dict_table_t table, mem_heap_t heap, dict_col_t column, table_id_t table_id, const char *col_name, const rec_t rec, ulint *nth_v_col)
	Load a table column definition from a SYS_COLUMNS record to dict_table_t. More...

static const char *	dict_load_virtual_low (dict_table_t table, dict_col_t column, table_id_t table_id, ulint pos, ulint base_pos, const rec_t *rec)
	Loads a virtual column "mapping" (to base columns) information from a SYS_VIRTUAL record. More...

static void	dict_load_virtual_one_col (dict_table_t table, ulint nth_v_col, dict_v_col_t v_col, mem_heap_t *heap)
	Loads SYS_VIRTUAL info for one virtual column. More...

static void	dict_load_virtual (dict_table_t table, mem_heap_t heap)
	Loads info from SYS_VIRTUAL for virtual columns. More...

static const char *	dict_load_field_low (byte index_id, dict_index_t index, mem_heap_t heap, const rec_t rec)
	Loads an index field definition from a SYS_FIELDS record to dict_index_t. More...

const char *	dict_process_sys_tablespaces (mem_heap_t heap, const rec_t rec, space_id_t space, const char name, uint32_t flags)
	This function parses a SYS_TABLESPACES record, extracts necessary information from the record and returns to caller. More...

char *	dict_get_first_path (ulint space_id)
	Get the first filepath from SYS_DATAFILES for a given space_id. More...

static char *	dict_space_get_name (space_id_t space_id, mem_heap_t *callers_heap)
	Gets the space name from SYS_TABLESPACES for a given space ID. More...

static const char *	dict_sys_tables_rec_check (const rec_t *rec)
	Check the validity of a SYS_TABLES record Make sure the fields are the right length and that they do not contain invalid contents. More...

static bool	dict_sys_tablespaces_rec_read (const rec_t rec, space_id_t id, char name, uint32_t flags)
	Read and return the contents of a SYS_TABLESPACES record. More...

static space_id_t	dict_check_sys_tablespaces (bool validate)
	Load and check each general tablespace mentioned in the SYS_TABLESPACES. More...

static bool	dict_sys_tables_rec_read (const rec_t rec, const table_name_t &table_name, table_id_t table_id, space_id_t space_id, uint32_t n_cols, uint32_t flags, uint32_t flags2)
	Read and return 5 integer fields from a SYS_TABLES record. More...

static space_id_t	dict_check_sys_tables (bool validate)
	Load and check each non-predefined tablespace mentioned in SYS_TABLES. More...

static void	dict_load_columns (dict_table_t table, mem_heap_t heap)
	Load columns in an innodb cached table object from SYS_COLUMNS table. More...

static ulint	dict_load_fields (dict_index_t index, mem_heap_t heap)
	Loads definitions for index fields. More...

static dberr_t	dict_load_indexes (dict_table_t table, mem_heap_t heap, dict_err_ignore_t ignore_err)
	Loads definitions for table indexes. More...

void	dict_save_data_dir_path (dict_table_t table, char filepath)
	Using the table->heap, copy the null-terminated filepath into table->data_dir_path. More...

void	dict_get_and_save_data_dir_path (dict_table_t *table, bool dict_mutex_own)
	Make sure the data_dir_path is saved in dict_table_t if DATA DIRECTORY was used. More...

void	dict_get_and_save_space_name (dict_table_t *table)
	Make sure the tablespace name is saved in dict_table_t if the table uses a general tablespace. More...

dict_table_t *	dict_load_table (const char name, bool cached, dict_err_ignore_t ignore_err, const std::string prev_table)
	Loads a table definition and also all its index definitions, and also the cluster definition if the table is a member in a cluster. More...

void	dict_load_tablespace (dict_table_t *table, dict_err_ignore_t ignore_err)
	Opens a tablespace for dict_load_table_one() More...

void	dict_load_sys_table (dict_table_t *table)
	This function is called when the database is booted. More...

static void	dict_load_foreign_cols (dict_foreign_t *foreign)
	Loads foreign key constraint col names (also for the referenced table). More...

static dberr_t	dict_load_foreign (const char id, const char *col_names, bool check_recursive, bool check_charsets, dict_err_ignore_t ignore_err, dict_names_t &fk_tables)
	Loads a foreign key constraint to the dictionary cache. More...

dberr_t	dict_load_foreigns (const char table_name, const char *col_names, bool check_recursive, bool check_charsets, dict_err_ignore_t ignore_err, dict_names_t &fk_tables)
	Loads foreign key constraints where the table is either the foreign key holder or where the table is referenced by a foreign key. More...

Variables
const char *	SYSTEM_TABLE_NAME []
	Following are the InnoDB system tables. More...

missing_sys_tblsp_t	missing_spaces

bool	has_discarded_tablespaces = false
	This bool denotes if we found a Table or Partition with discarded Tablespace during load of SYS_TABLES (in dict_check_sys_tables). More...

bool	srv_load_corrupted = false

static const char *	dict_load_index_del = "delete-marked record in SYS_INDEXES"
	Error message for a delete-marked record in dict_load_index_low() More...

static const char *	dict_load_index_id_err = "SYS_INDEXES.TABLE_ID mismatch"
	Error message for table->id mismatch in dict_load_index_low() More...

static const char *	dict_load_column_del = "delete-marked record in SYS_COLUMN"
	Error message for a delete-marked record in dict_load_column_low() More...

static const char *	dict_load_virtual_del
	Error message for a delete-marked record in dict_load_virtual_low() More...

static const char *	dict_load_field_del = "delete-marked record in SYS_FIELDS"
	Error message for a delete-marked record in dict_load_field_low() More...

Detailed Description

Loads to the memory cache database object definitions from dictionary tables.

Created 4/24/1996 Heikki Tuuri

Function Documentation

◆ dict_check_sys_tables()

static space_id_t dict_check_sys_tables ( bool validate )

inlinestatic

Load and check each non-predefined tablespace mentioned in SYS_TABLES.

Search SYS_TABLES and check each tablespace mentioned that has not already been added to the fil_system. If it is valid, add it to the file_system list. Perform extra validation on the table if recovery from the REDO log occurred. TODO - This function is to be removed by WL#16210

Parameters

[in] validate Whether to do validation on the table.

Returns: the highest space ID found.

◆ dict_check_sys_tablespaces()

static space_id_t dict_check_sys_tablespaces ( bool validate )

inlinestatic

Load and check each general tablespace mentioned in the SYS_TABLESPACES.

Ignore system and file-per-table tablespaces. If it is valid, add it to the file_system list. TODO - This function is to be removed by WL#16210

Parameters

[in] validate true when the previous shutdown was not clean

Returns: the highest space ID found.

◆ dict_get_and_save_data_dir_path()

void dict_get_and_save_data_dir_path	(	dict_table_t *	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 SYS_DATAFILES.

Parameters

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

◆ dict_get_and_save_space_name()

void dict_get_and_save_space_name ( dict_table_t * table )

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 SYS_TABLESPACES.

Parameters

[in] table Table object

◆ dict_get_first_path()

char * dict_get_first_path ( ulint space_id )

Get the first filepath from SYS_DATAFILES for a given space_id.

Parameters

[in] space_id Tablespace ID

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

Return values

NULL	if no SYS_DATAFILES entry was found.

◆ dict_get_first_table_name_in_db()

char * dict_get_first_table_name_in_db ( const char * name )

Finds the first table name in the given database.

Returns: own: table name, NULL if does not exist; the caller must free the memory in the string!

Parameters

name	in: database name which ends in '/'

◆ dict_getnext_system()

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

This function gets the next system table record as it scans the table.

This function get the next system table record as we scan the table.

Returns: the next record if found, NULL if end of scan

Parameters

pcur	in/out: persistent cursor to the record
mtr	in: the mini-transaction

◆ dict_getnext_system_low()

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

static

This function gets the next system table record as it scans the table.

Returns: the next record if found, NULL if end of scan

Parameters

pcur	in/out: persistent cursor to the record
mtr	in: the mini-transaction

◆ dict_load_column_low()

static const char * dict_load_column_low	(	dict_table_t *	table,
		mem_heap_t *	heap,
		dict_col_t *	column,
		table_id_t *	table_id,
		const char **	col_name,
		const rec_t *	rec,
		ulint *	nth_v_col
	)

static

Load a table column definition from a SYS_COLUMNS record to dict_table_t.

Returns: error message, or NULL on success

Parameters

table	in/out: table, could be NULL if we just populate a dict_column_t struct with information from a SYS_COLUMNS record
heap	in/out: memory heap for temporary storage
column	out: dict_column_t to fill, or NULL if table != NULL
table_id	out: table id
col_name	out: column name
rec	in: SYS_COLUMNS record
nth_v_col	out: if not NULL, this records the "n" of "nth" virtual column

◆ dict_load_columns()

static void dict_load_columns	(	dict_table_t *	table,
		mem_heap_t *	heap
	)

static

Load columns in an innodb cached table object from SYS_COLUMNS table.

Parameters

[in,out]	table	Table cache object
[in,out]	heap	memory heap for temporary storage

◆ dict_load_field_low()

static const char * dict_load_field_low	(	byte *	index_id,
		dict_index_t *	index,
		mem_heap_t *	heap,
		const rec_t *	rec
	)

static

Loads an index field definition from a SYS_FIELDS record to dict_index_t.

Returns: error message

Return values

NULL	on success

Parameters

index_id	in/out: index id (8 bytes) an "in" value if index != NULL and "out" if index == NULL
index	in/out: index, could be NULL if we just populate a dict_field_t struct with information from a SYS_FIELDS record
heap	in/out: memory heap for temporary storage
rec	in: SYS_FIELDS record

◆ dict_load_fields()

static ulint dict_load_fields	(	dict_index_t *	index,
		mem_heap_t *	heap
	)

static

Loads definitions for index fields.

Returns: DB_SUCCESS if ok, DB_CORRUPTION if corruption

Parameters

index	in/out: index whose fields to load
heap	in: memory heap for temporary storage

◆ dict_load_foreign()

static dberr_t dict_load_foreign	(	const char *	id,
		const char **	col_names,
		bool	check_recursive,
		bool	check_charsets,
		dict_err_ignore_t	ignore_err,
		dict_names_t &	fk_tables
	)

static

Loads a foreign key constraint to the dictionary cache.

If the referenced table is not yet loaded, it is added in the output parameter (fk_tables).

Returns: DB_SUCCESS or error code

Parameters

id	in: foreign constraint id, must be '\0'-terminated
col_names	in: column names, or NULL to use foreign->foreign_table->col_names
check_recursive	in: whether to record the foreign table parent count to avoid unlimited recursive load of chained foreign tables
check_charsets	in: whether to check charset compatibility
ignore_err	in: error to be ignored
fk_tables	out: the foreign key constraint is added to the dictionary cache only if the referenced table is already in cache. Otherwise, the foreign key constraint is not added to cache, and the referenced table is added to this stack.

◆ dict_load_foreign_cols()

static void dict_load_foreign_cols ( dict_foreign_t * foreign )

static

Loads foreign key constraint col names (also for the referenced table).

Members that must be set (and valid) in foreign: foreign->heap foreign->n_fields foreign->id ('\0'-terminated) Members that will be created and set by this function: foreign->foreign_col_names[i] foreign->referenced_col_namesi

Parameters

foreign in/out: foreign constraint object

◆ dict_load_foreigns()

dberr_t dict_load_foreigns	(	const char *	table_name,
		const char **	col_names,
		bool	check_recursive,
		bool	check_charsets,
		dict_err_ignore_t	ignore_err,
		dict_names_t &	fk_tables
	)

Loads foreign key constraints where the table is either the foreign key holder or where the table is referenced by a foreign key.

Adds these constraints to the data dictionary.

The foreign key constraint is loaded only if the referenced table is also in the dictionary cache. If the referenced table is not in dictionary cache, then it is added to the output parameter (fk_tables).

Returns: DB_SUCCESS or error code

Parameters

table_name	in: table name
col_names	in: column names, or NULL to use table->col_names
check_recursive	in: Whether to check recursive load of tables chained by FK
check_charsets	in: whether to check charset compatibility
ignore_err	in: error to be ignored
fk_tables	out: stack of table names which must be loaded subsequently to load all the foreign key constraints.

◆ dict_load_index_low()

static const char * dict_load_index_low	(	byte *	table_id,
		const char *	table_name,
		mem_heap_t *	heap,
		const rec_t *	rec,
		bool	allocate,
		dict_index_t **	index
	)

static

Load an index definition from a SYS_INDEXES record to dict_index_t.

If allocate=true, we will create a dict_index_t structure and fill it accordingly. If allocated=false, the dict_index_t will be supplied by the caller and filled with information read from the record.

Returns: error message, or NULL on success

Parameters

table_id	in/out: table id (8 bytes), an "in" value if allocate=true and "out" when allocate=false
table_name	in: table name
heap	in/out: temporary memory heap
rec	in: SYS_INDEXES record
allocate	in: true=allocate index, false=fill in a pre-allocated index
index	out,own: index, or NULL

◆ dict_load_indexes()

static dberr_t dict_load_indexes	(	dict_table_t *	table,
		mem_heap_t *	heap,
		dict_err_ignore_t	ignore_err
	)

static

Loads definitions for table indexes.

Adds them to the data dictionary cache.

Returns: DB_SUCCESS if ok, DB_CORRUPTION if corruption of dictionary table or DB_UNSUPPORTED if table has unknown index type

Parameters

table	in/out: table
heap	in: memory heap for temporary storage
ignore_err	in: error to be ignored when loading the index definition

◆ dict_load_is_system_table()

static bool dict_load_is_system_table ( const char * name )

static

This variant is based on name comparison and is used because system table id array is not built yet.

Parameters

[in] name InnoDB table name

Returns: true if table name is InnoDB SYSTEM table

◆ dict_load_sys_table()

void dict_load_sys_table ( dict_table_t * table )

This function is called when the database is booted.

Loads system table index definitions except for the clustered index which is added to the dictionary cache at booting before calling this function.

Parameters

table in: system table

◆ dict_load_table()

dict_table_t * dict_load_table	(	const char *	name,
		bool	cached,
		dict_err_ignore_t	ignore_err,
		const std::string *	prev_table = `nullptr`
	)

Loads a table definition and also all its index definitions, and also the cluster definition if the table is a member in a cluster.

Also loads all foreign key constraints where the foreign key is in the table or where a foreign key references columns in this table.

Parameters

[in]	name	Table name in the dbname/tablename format
[in]	cached	true=add to cache, false=do not
[in]	ignore_err	Error to be ignored when loading table and its index definition
[in]	prev_table	previous table name. The current table load is happening because of the load of the previous table name. This parameter is used to check for cyclic calls.

Returns: table, NULL if does not exist; if the table is stored in an .ibd file, but the file does not exist, then we set the ibd_file_missing flag in the table object we return.

◆ dict_load_table_low()

static const char * dict_load_table_low	(	table_name_t &	name,
		const rec_t *	rec,
		dict_table_t **	table
	)

static

Loads a table definition from a SYS_TABLES record to dict_table_t.

Does not load any columns or indexes.

Parameters

[in]	name	Table name
[in]	rec	SYS_TABLES record
[out]	table	Table, or NULL

Returns: error message, or NULL on success

◆ dict_load_table_one()

static dict_table_t * dict_load_table_one	(	table_name_t &	name,
		bool	cached,
		dict_err_ignore_t	ignore_err,
		dict_names_t &	fk_tables,
		const std::string *	prev_table
	)

static

Loads a table definition and also all its index definitions.

Loads those foreign key constraints whose referenced table is already in dictionary cache. If a foreign key constraint is not loaded, then the referenced table is pushed into the output stack (fk_tables), if it is not NULL. These tables must be subsequently loaded so that all the foreign key constraints are loaded into memory.

Parameters

[in]	name	Table name in the db/tablename format
[in]	cached	true=add to cache, false=do not
[in]	ignore_err	Error to be ignored when loading table and its index definition
[out]	fk_tables	Related table names that must also be loaded to ensure that all foreign key constraints are loaded.
[in]	prev_table	previous table name. The current table load is happening because of the load of the previous table name. This parameter is used to check for cyclic calls.

Returns: table, NULL if does not exist; if the table is stored in an .ibd file, but the file does not exist, then we set the ibd_file_missing flag true in the table object we return

◆ dict_load_tablespace()

void dict_load_tablespace	(	dict_table_t *	table,
		dict_err_ignore_t	ignore_err
	)

Opens a tablespace for dict_load_table_one()

Parameters

[in,out]	table	A table that refers to the tablespace to open
[in]	ignore_err	Whether to ignore an error.

◆ dict_load_virtual()

static void dict_load_virtual	(	dict_table_t *	table,
		mem_heap_t *	heap
	)

static

Loads info from SYS_VIRTUAL for virtual columns.

Parameters

[in,out]	table	table
[in]	heap	memory heap

◆ dict_load_virtual_low()

static const char * dict_load_virtual_low	(	dict_table_t *	table,
		dict_col_t **	column,
		table_id_t *	table_id,
		ulint *	pos,
		ulint *	base_pos,
		const rec_t *	rec
	)

static

Loads a virtual column "mapping" (to base columns) information from a SYS_VIRTUAL record.

Parameters

[in,out]	table	table
[in,out]	column	mapped base column's dict_column_t
[in,out]	table_id	table id
[in,out]	pos	virtual column position
[in,out]	base_pos	base column position
[in]	rec	SYS_VIRTUAL record

Returns: error message, or NULL on success

◆ dict_load_virtual_one_col()

static void dict_load_virtual_one_col	(	dict_table_t *	table,
		ulint	nth_v_col,
		dict_v_col_t *	v_col,
		mem_heap_t *	heap
	)

static

Loads SYS_VIRTUAL info for one virtual column.

Parameters

[in,out]	table	table
[in]	nth_v_col	virtual column sequence num
[in,out]	v_col	virtual column
[in,out]	heap	memory heap

◆ dict_process_sys_tablespaces()

const char * dict_process_sys_tablespaces	(	mem_heap_t *	heap,
		const rec_t *	rec,
		space_id_t *	space,
		const char **	name,
		uint32_t *	flags
	)

This function parses a SYS_TABLESPACES record, extracts necessary information from the record and returns to caller.

Returns: error message, or NULL on success

Parameters

heap	in/out: heap memory
rec	in: current SYS_TABLESPACES rec
space	out: space id
name	out: tablespace name
flags	out: tablespace flags

◆ dict_save_data_dir_path()

void dict_save_data_dir_path	(	dict_table_t *	table,
		char *	filepath
	)

Using the table->heap, copy the null-terminated filepath into table->data_dir_path.

The data directory path is derived from the filepath by stripping the the table->name.m_name component suffix. If the filepath is not of the correct form (".../db/table.ibd"), then table->data_dir_path will remain nullptr.

Parameters

[in,out]	table	table instance
[in]	filepath	filepath of tablespace

◆ dict_space_get_name()

static char * dict_space_get_name	(	space_id_t	space_id,
		mem_heap_t *	callers_heap
	)

static

Gets the space name from SYS_TABLESPACES for a given space ID.

Parameters

[in]	space_id	Tablespace ID
[in]	callers_heap	A heap to allocate from, may be NULL

Returns: Tablespace name (caller is responsible to free it)

Return values

NULL	if no dictionary entry was found.

◆ dict_startscan_system()

const rec_t * dict_startscan_system	(	btr_pcur_t *	pcur,
		mtr_t *	mtr,
		dict_system_id_t	system_id
	)

This function opens a system table, and returns the first record.

This function opens a system table, and return the first record.

Returns: first record of the system table

Parameters

pcur	out: persistent cursor to the record
mtr	in: the mini-transaction
system_id	in: which system table to open

◆ dict_sys_tables_rec_check()

static const char * dict_sys_tables_rec_check ( const rec_t * rec )

static

Check the validity of a SYS_TABLES record Make sure the fields are the right length and that they do not contain invalid contents.

Parameters

[in] rec SYS_TABLES record

Returns: error message, or NULL on success

◆ dict_sys_tables_rec_read()

static bool dict_sys_tables_rec_read	(	const rec_t *	rec,
		const table_name_t &	table_name,
		table_id_t *	table_id,
		space_id_t *	space_id,
		uint32_t *	n_cols,
		uint32_t *	flags,
		uint32_t *	flags2
	)

static

Read and return 5 integer fields from a SYS_TABLES record.

Parameters

[in]	rec	A record of SYS_TABLES
[in]	table_name	Table Name, the same as SYS_TABLES.NAME
[out]	table_id	Pointer to the table_id for this table
[out]	space_id	Pointer to the space_id for this table
[out]	n_cols	Pointer to number of columns for this table.
[out]	flags	Pointer to table flags
[out]	flags2	Pointer to table flags2

Returns: true if the record was read correctly, false if not.

◆ dict_sys_tablespaces_rec_read()

static bool dict_sys_tablespaces_rec_read	(	const rec_t *	rec,
		space_id_t *	id,
		char *	name,
		uint32_t *	flags
	)

static

Read and return the contents of a SYS_TABLESPACES record.

Parameters

[in]	rec	A record of SYS_TABLESPACES
[out]	id	Pointer to the space_id for this table
[in,out]	name	Buffer for Tablespace Name of length NAME_LEN
[out]	flags	Pointer to tablespace flags

Returns: true if the record was read correctly, false if not.

◆ name_of_col_is()

static bool name_of_col_is	(	const dict_table_t *	table,
		const dict_index_t *	index,
		ulint	i,
		const char *	name
	)

static

Compare the name of an index column.

Returns: true if the i'th column of index is 'name'.

Parameters

table	in: table
index	in: index
i	in: index field offset
name	in: name to compare to

Variable Documentation

◆ dict_load_column_del

const char* dict_load_column_del = "delete-marked record in SYS_COLUMN"

static

Error message for a delete-marked record in dict_load_column_low()

◆ dict_load_field_del

const char* dict_load_field_del = "delete-marked record in SYS_FIELDS"

static

Error message for a delete-marked record in dict_load_field_low()

◆ dict_load_index_del

const char* dict_load_index_del = "delete-marked record in SYS_INDEXES"

static

Error message for a delete-marked record in dict_load_index_low()

◆ dict_load_index_id_err

const char* dict_load_index_id_err = "SYS_INDEXES.TABLE_ID mismatch"

static

Error message for table->id mismatch in dict_load_index_low()

◆ dict_load_virtual_del

const char* dict_load_virtual_del

static

Initial value:

=

"delete-marked record in SYS_VIRTUAL"

Error message for a delete-marked record in dict_load_virtual_low()

◆ has_discarded_tablespaces

bool has_discarded_tablespaces = false

This bool denotes if we found a Table or Partition with discarded Tablespace during load of SYS_TABLES (in dict_check_sys_tables).

TODO To be removed in WL#16210

◆ missing_spaces

missing_sys_tblsp_t missing_spaces

◆ srv_load_corrupted

bool srv_load_corrupted = false

◆ SYSTEM_TABLE_NAME

const char* SYSTEM_TABLE_NAME[]

Initial value:

= {
    "SYS_TABLES",      "SYS_INDEXES",   "SYS_COLUMNS",
    "SYS_FIELDS",      "SYS_FOREIGN",   "SYS_FOREIGN_COLS",
    "SYS_TABLESPACES", "SYS_DATAFILES", "SYS_VIRTUAL"}

Following are the InnoDB system tables.

The positions in this array are referenced by enum dict_system_table_id.

Functions

Variables

Detailed Description

Function Documentation

◆ dict_check_sys_tables()

◆ dict_check_sys_tablespaces()

◆ dict_get_and_save_data_dir_path()

◆ dict_get_and_save_space_name()

◆ dict_get_first_path()

◆ dict_get_first_table_name_in_db()

◆ dict_getnext_system()

◆ dict_getnext_system_low()

◆ dict_load_column_low()

◆ dict_load_columns()

◆ dict_load_field_low()

◆ dict_load_fields()

◆ dict_load_foreign()

◆ dict_load_foreign_cols()

◆ dict_load_foreigns()

◆ dict_load_index_low()

◆ dict_load_indexes()

◆ dict_load_is_system_table()

◆ dict_load_sys_table()

◆ dict_load_table()

◆ dict_load_table_low()

◆ dict_load_table_one()

◆ dict_load_tablespace()

◆ dict_load_virtual()

◆ dict_load_virtual_low()

◆ dict_load_virtual_one_col()

◆ dict_process_sys_tablespaces()

◆ dict_save_data_dir_path()

◆ dict_space_get_name()

◆ dict_startscan_system()

◆ dict_sys_tables_rec_check()

◆ dict_sys_tables_rec_read()

◆ dict_sys_tablespaces_rec_read()

◆ name_of_col_is()

Variable Documentation

◆ dict_load_column_del

◆ dict_load_field_del

◆ dict_load_index_del

◆ dict_load_index_id_err

◆ dict_load_virtual_del

◆ has_discarded_tablespaces

◆ missing_spaces

◆ srv_load_corrupted

◆ SYSTEM_TABLE_NAME