207 lines
8.9 KiB
C++
207 lines
8.9 KiB
C++
/*****************************************************************************
|
|
|
|
Copyright (c) 1996, 2019, Oracle and/or its affiliates. All Rights Reserved.
|
|
|
|
This program is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License, version 2.0, as published by the
|
|
Free Software Foundation.
|
|
|
|
This program is also distributed with certain software (including but not
|
|
limited to OpenSSL) that is licensed under separate terms, as designated in a
|
|
particular file or component or in included license documentation. The authors
|
|
of MySQL hereby grant you an additional permission to link the program and
|
|
your derivative works with the separately licensed software that they have
|
|
included with MySQL.
|
|
|
|
This program is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/** @file include/dict0load.h
|
|
Loads to the memory cache database object definitions
|
|
from dictionary tables
|
|
|
|
Created 4/24/1996 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#ifndef dict0load_h
|
|
#define dict0load_h
|
|
|
|
#include "btr0types.h"
|
|
#include "dict0types.h"
|
|
#include "fil0fil.h"
|
|
#include "mem0mem.h"
|
|
#include "trx0types.h"
|
|
#include "univ.i"
|
|
#include "ut0byte.h"
|
|
#include "ut0new.h"
|
|
|
|
#include <deque>
|
|
|
|
/** A stack of table names related through foreign key constraints */
|
|
typedef std::deque<const char *, ut_allocator<const char *>> dict_names_t;
|
|
|
|
/** enum that defines all system table IDs. @see SYSTEM_TABLE_NAME[] */
|
|
enum dict_system_id_t {
|
|
SYS_TABLES = 0,
|
|
SYS_INDEXES,
|
|
SYS_COLUMNS,
|
|
SYS_FIELDS,
|
|
SYS_FOREIGN,
|
|
SYS_FOREIGN_COLS,
|
|
SYS_TABLESPACES,
|
|
SYS_DATAFILES,
|
|
SYS_VIRTUAL,
|
|
|
|
/* This must be last item. Defines the number of system tables. */
|
|
SYS_NUM_SYSTEM_TABLES
|
|
};
|
|
|
|
/** Status bit for dict_process_sys_tables_rec_and_mtr_commit() */
|
|
enum dict_table_info_t {
|
|
DICT_TABLE_LOAD_FROM_RECORD = 0, /*!< Directly populate a dict_table_t
|
|
structure with information from
|
|
a SYS_TABLES record */
|
|
DICT_TABLE_LOAD_FROM_CACHE = 1 /*!< Check first whether dict_table_t
|
|
is in the cache, if so, return it */
|
|
};
|
|
|
|
extern const char *SYSTEM_TABLE_NAME[];
|
|
|
|
/** Finds the first table name in the given database.
|
|
@return own: table name, NULL if does not exist; the caller must free
|
|
the memory in the string! */
|
|
char *dict_get_first_table_name_in_db(
|
|
const char *name); /*!< in: database name which ends to '/' */
|
|
|
|
/** Get the first filepath from SYS_DATAFILES for a given space_id.
|
|
@param[in] space_id Tablespace ID
|
|
@return First filepath (caller must invoke ut_free() on it)
|
|
@retval NULL if no SYS_DATAFILES entry was found. */
|
|
char *dict_get_first_path(ulint space_id);
|
|
|
|
/** Make sure the data_file_name is saved in dict_table_t if needed.
|
|
Try to read it from the fil_system first, then from SYS_DATAFILES.
|
|
@param[in] table Table object
|
|
@param[in] dict_mutex_own true if dict_sys->mutex is owned already */
|
|
void dict_get_and_save_data_dir_path(dict_table_t *table, bool dict_mutex_own);
|
|
|
|
/** Make sure the tablespace name is saved in dict_table_t if needed.
|
|
Try to read it from the file dictionary first, then from SYS_TABLESPACES.
|
|
@param[in] table Table object
|
|
@param[in] dict_mutex_own true if dict_sys->mutex is owned already */
|
|
void dict_get_and_save_space_name(dict_table_t *table, bool dict_mutex_own);
|
|
|
|
/** 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.
|
|
@param[in] name Table name in the dbname/tablename format
|
|
@param[in] cached true=add to cache, false=do not
|
|
@param[in] ignore_err Error to be ignored when loading
|
|
table and its index definition
|
|
@return 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_table_t *dict_load_table(const char *name, bool cached,
|
|
dict_err_ignore_t ignore_err);
|
|
|
|
/** Loads a table object based on the table id.
|
|
@return table; NULL if table does not exist */
|
|
dict_table_t *dict_load_table_on_id(
|
|
table_id_t table_id, /*!< in: table id */
|
|
dict_err_ignore_t ignore_err); /*!< in: errors to ignore
|
|
when loading the 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. */
|
|
void dict_load_sys_table(dict_table_t *table); /*!< in: system table */
|
|
/** 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).
|
|
|
|
@return DB_SUCCESS or error code */
|
|
dberr_t dict_load_foreigns(
|
|
const char *table_name, /*!< in: table name */
|
|
const char **col_names, /*!< in: column names, or NULL
|
|
to use table->col_names */
|
|
bool check_recursive, /*!< in: Whether to check
|
|
recursive load of tables
|
|
chained by FK */
|
|
bool check_charsets, /*!< in: whether to check
|
|
charset compatibility */
|
|
dict_err_ignore_t ignore_err, /*!< in: error to be ignored */
|
|
dict_names_t &fk_tables) /*!< out: stack of table names
|
|
which must be loaded
|
|
subsequently to load all the
|
|
foreign key constraints. */
|
|
MY_ATTRIBUTE((warn_unused_result));
|
|
|
|
/** This function opens a system table, and return the first record.
|
|
@return first record of the system table */
|
|
const rec_t *dict_startscan_system(
|
|
btr_pcur_t *pcur, /*!< out: persistent cursor to
|
|
the record */
|
|
mtr_t *mtr, /*!< in: the mini-transaction */
|
|
dict_system_id_t system_id); /*!< in: which system table to open */
|
|
/** This function get the next system table record as we scan the table.
|
|
@return the record if found, NULL if end of scan. */
|
|
const rec_t *dict_getnext_system(btr_pcur_t *pcur, /*!< in/out: persistent
|
|
cursor to the record */
|
|
mtr_t *mtr); /*!< in: the mini-transaction */
|
|
|
|
/** This function parses a SYS_TABLESPACES record, extracts necessary
|
|
information from the record and returns to caller.
|
|
@return error message, or NULL on success */
|
|
const char *dict_process_sys_tablespaces(
|
|
mem_heap_t *heap, /*!< in/out: heap memory */
|
|
const rec_t *rec, /*!< in: current SYS_TABLESPACES rec */
|
|
space_id_t *space, /*!< out: space id */
|
|
const char **name, /*!< out: tablespace name */
|
|
uint32_t *flags); /*!< out: tablespace flags */
|
|
/** Opens a tablespace for dict_load_table_one()
|
|
@param[in,out] table A table that refers to the tablespace to open
|
|
@param[in,out] heap A memory heap
|
|
@param[in] ignore_err Whether to ignore an error. */
|
|
void dict_load_tablespace(dict_table_t *table, mem_heap_t *heap,
|
|
dict_err_ignore_t ignore_err);
|
|
|
|
/** Using the table->heap, copy the null-terminated filepath into
|
|
table->data_dir_path. The data directory patch is derived form the
|
|
filepath by stripping the the table->name.m_name component suffix.
|
|
@param[in,out] table table obj
|
|
@param[in] filepath filepath of tablespace */
|
|
void dict_save_data_dir_path(dict_table_t *table, char *filepath);
|
|
|
|
/** Load all tablespaces during upgrade */
|
|
void dict_load_tablespaces_for_upgrade();
|
|
|
|
/* Comparator for missing_spaces. */
|
|
struct space_compare {
|
|
bool operator()(const fil_space_t *lhs, const fil_space_t *rhs) const {
|
|
return (lhs->id < rhs->id);
|
|
}
|
|
};
|
|
|
|
/* This is set of tablespaces that are not found in SYS_TABLESPACES.
|
|
InnoDB tablespaces before 5.6 are not registered in SYS_TABLESPACES.
|
|
So we maintain a std::set, which is later used to register the
|
|
tablespaces to dictionary table mysql.tablespaces */
|
|
using missing_sys_tblsp_t = std::set<fil_space_t *, space_compare>;
|
|
extern missing_sys_tblsp_t missing_spaces;
|
|
|
|
#include "dict0load.ic"
|
|
|
|
#endif
|