dict0mem.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:16k
- /******************************************************
- Data dictionary memory object creation
- (c) 1996 Innobase Oy
- Created 1/8/1996 Heikki Tuuri
- *******************************************************/
- #ifndef dict0mem_h
- #define dict0mem_h
- #include "univ.i"
- #include "dict0types.h"
- #include "data0type.h"
- #include "data0data.h"
- #include "mem0mem.h"
- #include "rem0types.h"
- #include "btr0types.h"
- #include "ut0mem.h"
- #include "ut0lst.h"
- #include "ut0rnd.h"
- #include "ut0byte.h"
- #include "sync0rw.h"
- #include "lock0types.h"
- #include "hash0hash.h"
- #include "que0types.h"
- /* Type flags of an index: OR'ing of the flags is allowed to define a
- combination of types */
- #define DICT_CLUSTERED 1 /* clustered index */
- #define DICT_UNIQUE 2 /* unique index */
- #define DICT_UNIVERSAL 4 /* index which can contain records from any
- other index */
- #define DICT_IBUF 8 /* insert buffer tree */
-
- /* Flags for ordering an index field: OR'ing of the flags allowed */
- #define DICT_DESCEND 1 /* in descending order (default ascending) */
- /* Types for a table object */
- #define DICT_TABLE_ORDINARY 1
- #define DICT_TABLE_CLUSTER_MEMBER 2
- #define DICT_TABLE_CLUSTER 3 /* this means that the table is
- really a cluster definition */
- /**************************************************************************
- Creates a table memory object. */
- dict_table_t*
- dict_mem_table_create(
- /*==================*/
- /* out, own: table object */
- const char* name, /* in: table name */
- ulint space, /* in: space where the clustered index
- of the table is placed; this parameter
- is ignored if the table is made
- a member of a cluster */
- ulint n_cols); /* in: number of columns */
- /**************************************************************************
- Creates a cluster memory object. */
- dict_cluster_t*
- dict_mem_cluster_create(
- /*====================*/
- /* out, own: cluster object (where the
- type dict_cluster_t == dict_table_t) */
- const char* name, /* in: cluster name */
- ulint space, /* in: space where the clustered
- indexes of the member tables are
- placed */
- ulint n_cols, /* in: number of columns */
- ulint mix_len); /* in: length of the common key prefix
- in the cluster */
- /**************************************************************************
- Declares a non-published table as a member in a cluster. */
- void
- dict_mem_table_make_cluster_member(
- /*===============================*/
- dict_table_t* table, /* in: non-published table */
- const char* cluster_name); /* in: cluster name */
- /**************************************************************************
- Adds a column definition to a table. */
- void
- dict_mem_table_add_col(
- /*===================*/
- dict_table_t* table, /* in: table */
- const char* name, /* in: column name */
- ulint mtype, /* in: main datatype */
- ulint prtype, /* in: precise type */
- ulint len, /* in: length */
- ulint prec); /* in: precision */
- /**************************************************************************
- Creates an index memory object. */
- dict_index_t*
- dict_mem_index_create(
- /*==================*/
- /* out, own: index object */
- const char* table_name, /* in: table name */
- const char* index_name, /* in: index name */
- ulint space, /* in: space where the index tree is
- placed, ignored if the index is of
- the clustered type */
- ulint type, /* in: DICT_UNIQUE,
- DICT_CLUSTERED, ... ORed */
- ulint n_fields); /* in: number of fields */
- /**************************************************************************
- Adds a field definition to an index. NOTE: does not take a copy
- of the column name if the field is a column. The memory occupied
- by the column name may be released only after publishing the index. */
- void
- dict_mem_index_add_field(
- /*=====================*/
- dict_index_t* index, /* in: index */
- const char* name, /* in: column name */
- ulint order, /* in: order criterion; 0 means an
- ascending order */
- ulint prefix_len); /* in: 0 or the column prefix length
- in a MySQL index like
- INDEX (textcol(25)) */
- /**************************************************************************
- Frees an index memory object. */
- void
- dict_mem_index_free(
- /*================*/
- dict_index_t* index); /* in: index */
- /**************************************************************************
- Creates and initializes a foreign constraint memory object. */
- dict_foreign_t*
- dict_mem_foreign_create(void);
- /*=========================*/
- /* out, own: foreign constraint struct */
- /* Data structure for a column in a table */
- struct dict_col_struct{
- hash_node_t hash; /* hash chain node */
- ulint ind; /* table column position (they are numbered
- starting from 0) */
- ulint clust_pos;/* position of the column in the
- clustered index */
- ulint ord_part;/* count of how many times this column
- appears in ordering fields of an index */
- const char* name; /* name */
- dtype_t type; /* data type */
- dict_table_t* table; /* back pointer to table of this column */
- ulint aux; /* this is used as an auxiliary variable
- in some of the functions below */
- };
- /* DICT_MAX_COL_PREFIX_LEN is measured in bytes. Starting from 4.1.6, we
- set max col prefix len to < 3 * 256, so that one can create a column prefix
- index on 255 characters of a TEXT field also in the UTF-8 charset. In that
- charset, a character may take at most 3 bytes. */
- #define DICT_MAX_COL_PREFIX_LEN 768
- /* Data structure for a field in an index */
- struct dict_field_struct{
- dict_col_t* col; /* pointer to the table column */
- const char* name; /* name of the column */
- ulint order; /* flags for ordering this field:
- DICT_DESCEND, ... */
- ulint prefix_len; /* 0 or the length of the column
- prefix in bytes in a MySQL index of
- type, e.g., INDEX (textcol(25));
- must be smaller than
- DICT_MAX_COL_PREFIX_LEN; NOTE that
- in the UTF-8 charset, MySQL sets this
- to 3 * the prefix len in UTF-8 chars */
- };
- /* Data structure for an index tree */
- struct dict_tree_struct{
- ulint type; /* tree type */
- dulint id; /* id of the index stored in the tree, in the
- case of a mixed index, the id of the clustered
- index of the cluster table */
- ulint space; /* space of index tree */
- ulint page; /* index tree root page number */
- byte pad[64];/* Padding to prevent other memory hotspots on
- the same memory cache line */
- rw_lock_t lock; /* read-write lock protecting the upper levels
- of the index tree */
- ulint mem_fix;/* count of how many times this tree
- struct has been memoryfixed (by mini-
- transactions wanting to access the index
- tree) */
- UT_LIST_BASE_NODE_T(dict_index_t)
- tree_indexes; /* list of indexes stored in the
- index tree: if the tree is not of the
- mixed type there is only one index in
- the list; if the tree is of the mixed
- type, the first index in the list is the
- index of the cluster which owns the tree */
- ulint magic_n;/* magic number */
- };
- #define DICT_TREE_MAGIC_N 7545676
- /* Data structure for an index */
- struct dict_index_struct{
- dulint id; /* id of the index */
- mem_heap_t* heap; /* memory heap */
- ulint type; /* index type */
- const char* name; /* index name */
- const char* table_name; /* table name */
- dict_table_t* table; /* back pointer to table */
- ulint space; /* space where the index tree is placed */
- ulint page_no;/* page number of the index tree root */
- ulint trx_id_offset;/* position of the the trx id column
- in a clustered index record, if the fields
- before it are known to be of a fixed size,
- 0 otherwise */
- ulint n_user_defined_cols;
- /* number of columns the user defined to
- be in the index: in the internal
- representation we add more columns */
- ulint n_uniq; /* number of fields from the beginning
- which are enough to determine an index
- entry uniquely */
- ulint n_def; /* number of fields defined so far */
- ulint n_fields;/* number of fields in the index */
- dict_field_t* fields; /* array of field descriptions */
- UT_LIST_NODE_T(dict_index_t)
- indexes;/* list of indexes of the table */
- dict_tree_t* tree; /* index tree struct */
- UT_LIST_NODE_T(dict_index_t)
- tree_indexes; /* list of indexes of the same index
- tree */
- ibool cached; /* TRUE if the index object is in the
- dictionary cache */
- btr_search_t* search_info; /* info used in optimistic searches */
- /*----------------------*/
- ib_longlong* stat_n_diff_key_vals;
- /* approximate number of different key values
- for this index, for each n-column prefix
- where n <= dict_get_n_unique(index); we
- periodically calculate new estimates */
- ulint stat_index_size;
- /* approximate index size in database pages */
- ulint stat_n_leaf_pages;
- /* approximate number of leaf pages in the
- index tree */
- ulint magic_n;/* magic number */
- };
- /* Data structure for a foreign key constraint; an example:
- FOREIGN KEY (A, B) REFERENCES TABLE2 (C, D) */
- struct dict_foreign_struct{
- mem_heap_t* heap; /* this object is allocated from
- this memory heap */
- char* id; /* id of the constraint as a
- null-terminated string */
- ulint type; /* 0 or DICT_FOREIGN_ON_DELETE_CASCADE
- or DICT_FOREIGN_ON_DELETE_SET_NULL */
- char* foreign_table_name;/* foreign table name */
- dict_table_t* foreign_table; /* table where the foreign key is */
- const char** foreign_col_names;/* names of the columns in the
- foreign key */
- char* referenced_table_name;/* referenced table name */
- dict_table_t* referenced_table;/* table where the referenced key
- is */
- const char** referenced_col_names;/* names of the referenced
- columns in the referenced table */
- ulint n_fields; /* number of indexes' first fields
- for which the the foreign key
- constraint is defined: we allow the
- indexes to contain more fields than
- mentioned in the constraint, as long
- as the first fields are as mentioned */
- dict_index_t* foreign_index; /* foreign index; we require that
- both tables contain explicitly defined
- indexes for the constraint: InnoDB
- does not generate new indexes
- implicitly */
- dict_index_t* referenced_index;/* referenced index */
- UT_LIST_NODE_T(dict_foreign_t)
- foreign_list; /* list node for foreign keys of the
- table */
- UT_LIST_NODE_T(dict_foreign_t)
- referenced_list;/* list node for referenced keys of the
- table */
- };
- /* The flags for ON_UPDATE and ON_DELETE can be ORed; the default is that
- a foreign key constraint is enforced, therefore RESTRICT just means no flag */
- #define DICT_FOREIGN_ON_DELETE_CASCADE 1
- #define DICT_FOREIGN_ON_DELETE_SET_NULL 2
- #define DICT_FOREIGN_ON_UPDATE_CASCADE 4
- #define DICT_FOREIGN_ON_UPDATE_SET_NULL 8
- #define DICT_FOREIGN_ON_DELETE_NO_ACTION 16
- #define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32
- #define DICT_INDEX_MAGIC_N 76789786
- /* Data structure for a database table */
- struct dict_table_struct{
- dulint id; /* id of the table or cluster */
- ulint type; /* DICT_TABLE_ORDINARY, ... */
- mem_heap_t* heap; /* memory heap */
- const char* name; /* table name */
- const char* dir_path_of_temp_table;/* NULL or the directory path
- where a TEMPORARY table that was explicitly
- created by a user should be placed if
- innodb_file_per_table is defined in my.cnf;
- in Unix this is usually /tmp/..., in Windows
- temp... */
- ulint space; /* space where the clustered index of the
- table is placed */
- ibool ibd_file_missing;/* TRUE if this is in a single-table
- tablespace and the .ibd file is missing; then
- we must return in ha_innodb.cc an error if the
- user tries to query such an orphaned table */
- ibool tablespace_discarded;/* this flag is set TRUE when the
- user calls DISCARD TABLESPACE on this table,
- and reset to FALSE in IMPORT TABLESPACE */
- hash_node_t name_hash; /* hash chain node */
- hash_node_t id_hash; /* hash chain node */
- ulint n_def; /* number of columns defined so far */
- ulint n_cols; /* number of columns */
- dict_col_t* cols; /* array of column descriptions */
- UT_LIST_BASE_NODE_T(dict_index_t)
- indexes; /* list of indexes of the table */
- UT_LIST_BASE_NODE_T(dict_foreign_t)
- foreign_list;/* list of foreign key constraints
- in the table; these refer to columns
- in other tables */
- UT_LIST_BASE_NODE_T(dict_foreign_t)
- referenced_list;/* list of foreign key constraints
- which refer to this table */
- UT_LIST_NODE_T(dict_table_t)
- table_LRU; /* node of the LRU list of tables */
- ulint mem_fix;/* count of how many times the table
- and its indexes has been fixed in memory;
- currently NOT used */
- ulint n_mysql_handles_opened;
- /* count of how many handles MySQL has opened
- to this table; dropping of the table is
- NOT allowed until this count gets to zero;
- MySQL does NOT itself check the number of
- open handles at drop */
- ulint n_foreign_key_checks_running;
- /* count of how many foreign key check
- operations are currently being performed
- on the table: we cannot drop the table while
- there are foreign key checks running on
- it! */
- ibool cached; /* TRUE if the table object has been added
- to the dictionary cache */
- lock_t* auto_inc_lock;/* a buffer for an auto-inc lock
- for this table: we allocate the memory here
- so that individual transactions can get it
- and release it without a need to allocate
- space from the lock heap of the trx:
- otherwise the lock heap would grow rapidly
- if we do a large insert from a select */
- dulint query_cache_inv_trx_id;
- /* transactions whose trx id < than this
- number are not allowed to store to the MySQL
- query cache or retrieve from it; when a trx
- with undo logs commits, it sets this to the
- value of the trx id counter for the tables it
- had an IX lock on */
- UT_LIST_BASE_NODE_T(lock_t)
- locks; /* list of locks on the table */
- /*----------------------*/
- dulint mix_id; /* if the table is a member in a cluster,
- this is its mix id */
- ulint mix_len;/* if the table is a cluster or a member
- this is the common key prefix lenght */
- ulint mix_id_len;/* mix id length in a compressed form */
- byte mix_id_buf[12];
- /* mix id of a mixed table written in
- a compressed form */
- const char* cluster_name; /* if the table is a member in a
- cluster, this is the name of the cluster */
- /*----------------------*/
- ibool does_not_fit_in_memory;
- /* this field is used to specify in simulations
- tables which are so big that disk should be
- accessed: disk access is simulated by
- putting the thread to sleep for a while;
- NOTE that this flag is not stored to the data
- dictionary on disk, and the database will
- forget about value TRUE if it has to reload
- the table definition from disk */
- /*----------------------*/
- ib_longlong stat_n_rows;
- /* approximate number of rows in the table;
- we periodically calculate new estimates */
- ulint stat_clustered_index_size;
- /* approximate clustered index size in
- database pages */
- ulint stat_sum_of_other_index_sizes;
- /* other indexes in database pages */
- ibool stat_initialized; /* TRUE if statistics have
- been calculated the first time
- after database startup or table creation */
- ulint stat_modified_counter;
- /* when a row is inserted, updated, or deleted,
- we add 1 to this number; we calculate new
- estimates for the stat_... values for the
- table and the indexes at an interval of 2 GB
- or when about 1 / 16 of table has been
- modified; also when the estimate operation is
- called for MySQL SHOW TABLE STATUS; the
- counter is reset to zero at statistics
- calculation; this counter is not protected by
- any latch, because this is only used for
- heuristics */
- /*----------------------*/
- mutex_t autoinc_mutex;
- /* mutex protecting the autoincrement
- counter */
- ibool autoinc_inited;
- /* TRUE if the autoinc counter has been
- inited; MySQL gets the init value by executing
- SELECT MAX(auto inc column) */
- ib_longlong autoinc;/* autoinc counter value to give to the
- next inserted row */
- ulint magic_n;/* magic number */
- };
- #define DICT_TABLE_MAGIC_N 76333786
-
- #ifndef UNIV_NONINL
- #include "dict0mem.ic"
- #endif
- #endif