dict0mem.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:16k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. Data dictionary memory object creation
  3. (c) 1996 Innobase Oy
  4. Created 1/8/1996 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef dict0mem_h
  7. #define dict0mem_h
  8. #include "univ.i"
  9. #include "dict0types.h"
  10. #include "data0type.h"
  11. #include "data0data.h"
  12. #include "mem0mem.h"
  13. #include "rem0types.h"
  14. #include "btr0types.h"
  15. #include "ut0mem.h"
  16. #include "ut0lst.h"
  17. #include "ut0rnd.h"
  18. #include "ut0byte.h"
  19. #include "sync0rw.h"
  20. #include "lock0types.h"
  21. #include "hash0hash.h"
  22. #include "que0types.h"
  23. /* Type flags of an index: OR'ing of the flags is allowed to define a
  24. combination of types */
  25. #define DICT_CLUSTERED 1 /* clustered index */
  26. #define DICT_UNIQUE 2 /* unique index */
  27. #define DICT_UNIVERSAL  4 /* index which can contain records from any
  28. other index */
  29. #define DICT_IBUF  8 /* insert buffer tree */
  30. /* Flags for ordering an index field: OR'ing of the flags allowed */
  31. #define DICT_DESCEND 1 /* in descending order (default ascending) */
  32. /* Types for a table object */
  33. #define DICT_TABLE_ORDINARY 1
  34. #define DICT_TABLE_CLUSTER_MEMBER 2
  35. #define DICT_TABLE_CLUSTER 3 /* this means that the table is
  36.   really a cluster definition */
  37. /**************************************************************************
  38. Creates a table memory object. */
  39. dict_table_t*
  40. dict_mem_table_create(
  41. /*==================*/
  42. /* out, own: table object */
  43. const char* name, /* in: table name */
  44. ulint space, /* in: space where the clustered index
  45. of the table is placed; this parameter
  46. is ignored if the table is made
  47. a member of a cluster */
  48. ulint n_cols); /* in: number of columns */
  49. /**************************************************************************
  50. Creates a cluster memory object. */
  51. dict_cluster_t*
  52. dict_mem_cluster_create(
  53. /*====================*/
  54. /* out, own: cluster object (where the
  55. type dict_cluster_t == dict_table_t) */
  56. const char* name, /* in: cluster name */
  57. ulint space, /* in: space where the clustered
  58. indexes of the member tables are
  59. placed */
  60. ulint n_cols, /* in: number of columns */
  61. ulint mix_len); /* in: length of the common key prefix
  62. in the cluster */
  63. /**************************************************************************
  64. Declares a non-published table as a member in a cluster. */
  65. void
  66. dict_mem_table_make_cluster_member(
  67. /*===============================*/
  68. dict_table_t* table, /* in: non-published table */
  69. const char* cluster_name); /* in: cluster name */
  70. /**************************************************************************
  71. Adds a column definition to a table. */
  72. void
  73. dict_mem_table_add_col(
  74. /*===================*/
  75. dict_table_t* table, /* in: table */
  76. const char* name, /* in: column name */
  77. ulint mtype, /* in: main datatype */
  78. ulint prtype, /* in: precise type */
  79. ulint len, /* in: length */
  80. ulint prec); /* in: precision */
  81. /**************************************************************************
  82. Creates an index memory object. */
  83. dict_index_t*
  84. dict_mem_index_create(
  85. /*==================*/
  86. /* out, own: index object */
  87. const char* table_name, /* in: table name */
  88. const char* index_name, /* in: index name */
  89. ulint space, /* in: space where the index tree is
  90. placed, ignored if the index is of
  91. the clustered type */
  92. ulint type, /* in: DICT_UNIQUE,
  93. DICT_CLUSTERED, ... ORed */
  94. ulint n_fields); /* in: number of fields */
  95. /**************************************************************************
  96. Adds a field definition to an index. NOTE: does not take a copy
  97. of the column name if the field is a column. The memory occupied
  98. by the column name may be released only after publishing the index. */
  99. void
  100. dict_mem_index_add_field(
  101. /*=====================*/
  102. dict_index_t* index, /* in: index */
  103. const char* name, /* in: column name */
  104. ulint order, /* in: order criterion; 0 means an
  105. ascending order */
  106. ulint prefix_len); /* in: 0 or the column prefix length
  107. in a MySQL index like
  108. INDEX (textcol(25)) */
  109. /**************************************************************************
  110. Frees an index memory object. */
  111. void
  112. dict_mem_index_free(
  113. /*================*/
  114. dict_index_t* index); /* in: index */
  115. /**************************************************************************
  116. Creates and initializes a foreign constraint memory object. */
  117. dict_foreign_t*
  118. dict_mem_foreign_create(void);
  119. /*=========================*/
  120. /* out, own: foreign constraint struct */
  121. /* Data structure for a column in a table */
  122. struct dict_col_struct{
  123. hash_node_t hash; /* hash chain node */
  124. ulint ind; /* table column position (they are numbered
  125. starting from 0) */
  126. ulint clust_pos;/* position of the column in the
  127. clustered index */
  128. ulint ord_part;/* count of how many times this column
  129. appears in ordering fields of an index */
  130. const char* name; /* name */
  131. dtype_t type; /* data type */
  132. dict_table_t* table; /* back pointer to table of this column */
  133. ulint aux; /* this is used as an auxiliary variable 
  134. in some of the functions below */
  135. };
  136. /* DICT_MAX_COL_PREFIX_LEN is measured in bytes. Starting from 4.1.6, we
  137. set max col prefix len to < 3 * 256, so that one can create a column prefix
  138. index on 255 characters of a TEXT field also in the UTF-8 charset. In that
  139. charset, a character may take at most 3 bytes. */
  140. #define DICT_MAX_COL_PREFIX_LEN 768
  141. /* Data structure for a field in an index */
  142. struct dict_field_struct{
  143. dict_col_t* col; /* pointer to the table column */
  144. const char* name; /* name of the column */
  145. ulint order; /* flags for ordering this field:
  146. DICT_DESCEND, ... */
  147. ulint prefix_len; /* 0 or the length of the column
  148. prefix in bytes in a MySQL index of
  149. type, e.g., INDEX (textcol(25));
  150. must be smaller than
  151. DICT_MAX_COL_PREFIX_LEN; NOTE that
  152. in the UTF-8 charset, MySQL sets this
  153. to 3 * the prefix len in UTF-8 chars */
  154. };
  155. /* Data structure for an index tree */
  156. struct dict_tree_struct{
  157. ulint type; /* tree type */
  158. dulint id; /* id of the index stored in the tree, in the
  159. case of a mixed index, the id of the clustered
  160. index of the cluster table */
  161. ulint space; /* space of index tree */
  162. ulint page; /* index tree root page number */
  163. byte pad[64];/* Padding to prevent other memory hotspots on
  164. the same memory cache line */
  165. rw_lock_t lock; /* read-write lock protecting the upper levels
  166. of the index tree */
  167. ulint mem_fix;/* count of how many times this tree
  168. struct has been memoryfixed (by mini-
  169. transactions wanting to access the index
  170. tree) */
  171. UT_LIST_BASE_NODE_T(dict_index_t)
  172. tree_indexes; /* list of indexes stored in the
  173. index tree: if the tree is not of the
  174. mixed type there is only one index in
  175. the list; if the tree is of the mixed
  176. type, the first index in the list is the
  177. index of the cluster which owns the tree */
  178. ulint magic_n;/* magic number */
  179. };
  180. #define DICT_TREE_MAGIC_N 7545676
  181. /* Data structure for an index */
  182. struct dict_index_struct{
  183. dulint id; /* id of the index */
  184. mem_heap_t* heap; /* memory heap */
  185. ulint type; /* index type */
  186. const char* name; /* index name */
  187. const char* table_name; /* table name */
  188. dict_table_t* table; /* back pointer to table */
  189. ulint space; /* space where the index tree is placed */
  190. ulint page_no;/* page number of the index tree root */
  191. ulint trx_id_offset;/* position of the the trx id column
  192. in a clustered index record, if the fields
  193. before it are known to be of a fixed size,
  194. 0 otherwise */
  195. ulint n_user_defined_cols;
  196. /* number of columns the user defined to
  197. be in the index: in the internal
  198. representation we add more columns */
  199. ulint n_uniq; /* number of fields from the beginning
  200. which are enough to determine an index
  201. entry uniquely */
  202. ulint n_def; /* number of fields defined so far */
  203. ulint n_fields;/* number of fields in the index */
  204. dict_field_t* fields; /* array of field descriptions */
  205. UT_LIST_NODE_T(dict_index_t)
  206. indexes;/* list of indexes of the table */
  207. dict_tree_t* tree; /* index tree struct */
  208. UT_LIST_NODE_T(dict_index_t)
  209. tree_indexes; /* list of indexes of the same index
  210. tree */
  211. ibool cached; /* TRUE if the index object is in the
  212. dictionary cache */
  213. btr_search_t* search_info; /* info used in optimistic searches */
  214. /*----------------------*/
  215. ib_longlong* stat_n_diff_key_vals;
  216. /* approximate number of different key values
  217. for this index, for each n-column prefix
  218. where n <= dict_get_n_unique(index); we
  219. periodically calculate new estimates */
  220. ulint stat_index_size;
  221. /* approximate index size in database pages */
  222. ulint stat_n_leaf_pages;
  223. /* approximate number of leaf pages in the
  224. index tree */
  225. ulint magic_n;/* magic number */
  226. };
  227. /* Data structure for a foreign key constraint; an example:
  228. FOREIGN KEY (A, B) REFERENCES TABLE2 (C, D) */
  229. struct dict_foreign_struct{
  230. mem_heap_t* heap; /* this object is allocated from
  231. this memory heap */
  232. char* id; /* id of the constraint as a
  233. null-terminated string */
  234. ulint type; /* 0 or DICT_FOREIGN_ON_DELETE_CASCADE
  235. or DICT_FOREIGN_ON_DELETE_SET_NULL */
  236. char* foreign_table_name;/* foreign table name */
  237. dict_table_t* foreign_table; /* table where the foreign key is */
  238. const char** foreign_col_names;/* names of the columns in the
  239. foreign key */
  240. char* referenced_table_name;/* referenced table name */
  241. dict_table_t* referenced_table;/* table where the referenced key
  242. is */
  243. const char** referenced_col_names;/* names of the referenced
  244. columns in the referenced table */
  245. ulint n_fields; /* number of indexes' first fields
  246. for which the the foreign key
  247. constraint is defined: we allow the
  248. indexes to contain more fields than
  249. mentioned in the constraint, as long
  250. as the first fields are as mentioned */ 
  251. dict_index_t* foreign_index; /* foreign index; we require that
  252. both tables contain explicitly defined
  253. indexes for the constraint: InnoDB
  254. does not generate new indexes
  255. implicitly */
  256. dict_index_t* referenced_index;/* referenced index */
  257. UT_LIST_NODE_T(dict_foreign_t)
  258. foreign_list; /* list node for foreign keys of the
  259. table */
  260. UT_LIST_NODE_T(dict_foreign_t)
  261. referenced_list;/* list node for referenced keys of the
  262. table */
  263. };
  264. /* The flags for ON_UPDATE and ON_DELETE can be ORed; the default is that
  265. a foreign key constraint is enforced, therefore RESTRICT just means no flag */
  266. #define DICT_FOREIGN_ON_DELETE_CASCADE 1
  267. #define DICT_FOREIGN_ON_DELETE_SET_NULL 2
  268. #define DICT_FOREIGN_ON_UPDATE_CASCADE 4
  269. #define DICT_FOREIGN_ON_UPDATE_SET_NULL 8
  270. #define DICT_FOREIGN_ON_DELETE_NO_ACTION 16
  271. #define DICT_FOREIGN_ON_UPDATE_NO_ACTION 32
  272. #define DICT_INDEX_MAGIC_N 76789786
  273. /* Data structure for a database table */
  274. struct dict_table_struct{
  275. dulint id; /* id of the table or cluster */
  276. ulint type; /* DICT_TABLE_ORDINARY, ... */
  277. mem_heap_t* heap; /* memory heap */
  278. const char* name; /* table name */
  279. const char* dir_path_of_temp_table;/* NULL or the directory path
  280. where a TEMPORARY table that was explicitly
  281. created by a user should be placed if
  282. innodb_file_per_table is defined in my.cnf;
  283. in Unix this is usually /tmp/..., in Windows
  284. temp... */
  285. ulint space; /* space where the clustered index of the
  286. table is placed */
  287. ibool ibd_file_missing;/* TRUE if this is in a single-table
  288. tablespace and the .ibd file is missing; then
  289. we must return in ha_innodb.cc an error if the
  290. user tries to query such an orphaned table */
  291. ibool tablespace_discarded;/* this flag is set TRUE when the
  292. user calls DISCARD TABLESPACE on this table,
  293. and reset to FALSE in IMPORT TABLESPACE */
  294. hash_node_t name_hash; /* hash chain node */
  295. hash_node_t id_hash; /* hash chain node */
  296. ulint n_def; /* number of columns defined so far */
  297. ulint n_cols; /* number of columns */
  298. dict_col_t* cols; /* array of column descriptions */
  299. UT_LIST_BASE_NODE_T(dict_index_t)
  300. indexes; /* list of indexes of the table */
  301. UT_LIST_BASE_NODE_T(dict_foreign_t)
  302. foreign_list;/* list of foreign key constraints
  303. in the table; these refer to columns
  304. in other tables */
  305. UT_LIST_BASE_NODE_T(dict_foreign_t)
  306. referenced_list;/* list of foreign key constraints
  307. which refer to this table */
  308. UT_LIST_NODE_T(dict_table_t)
  309. table_LRU; /* node of the LRU list of tables */
  310. ulint mem_fix;/* count of how many times the table 
  311. and its indexes has been fixed in memory;
  312. currently NOT used */
  313. ulint n_mysql_handles_opened;
  314. /* count of how many handles MySQL has opened
  315. to this table; dropping of the table is
  316. NOT allowed until this count gets to zero;
  317. MySQL does NOT itself check the number of
  318. open handles at drop */
  319. ulint n_foreign_key_checks_running;
  320. /* count of how many foreign key check
  321. operations are currently being performed
  322. on the table: we cannot drop the table while
  323. there are foreign key checks running on
  324. it! */
  325. ibool cached; /* TRUE if the table object has been added
  326. to the dictionary cache */
  327. lock_t* auto_inc_lock;/* a buffer for an auto-inc lock
  328. for this table: we allocate the memory here
  329. so that individual transactions can get it
  330. and release it without a need to allocate
  331. space from the lock heap of the trx:
  332. otherwise the lock heap would grow rapidly
  333. if we do a large insert from a select */
  334. dulint query_cache_inv_trx_id;
  335. /* transactions whose trx id < than this
  336. number are not allowed to store to the MySQL
  337. query cache or retrieve from it; when a trx
  338. with undo logs commits, it sets this to the
  339. value of the trx id counter for the tables it
  340. had an IX lock on */
  341. UT_LIST_BASE_NODE_T(lock_t)
  342. locks; /* list of locks on the table */
  343. /*----------------------*/
  344. dulint mix_id; /* if the table is a member in a cluster,
  345. this is its mix id */
  346. ulint mix_len;/* if the table is a cluster or a member
  347. this is the common key prefix lenght */
  348. ulint mix_id_len;/* mix id length in a compressed form */
  349. byte mix_id_buf[12];
  350. /* mix id of a mixed table written in
  351. a compressed form */
  352. const char* cluster_name; /* if the table is a member in a
  353. cluster, this is the name of the cluster */
  354. /*----------------------*/
  355. ibool does_not_fit_in_memory;
  356. /* this field is used to specify in simulations
  357. tables which are so big that disk should be
  358. accessed: disk access is simulated by
  359. putting the thread to sleep for a while;
  360. NOTE that this flag is not stored to the data
  361. dictionary on disk, and the database will
  362. forget about value TRUE if it has to reload
  363. the table definition from disk */
  364. /*----------------------*/
  365. ib_longlong stat_n_rows;
  366. /* approximate number of rows in the table;
  367. we periodically calculate new estimates */
  368. ulint stat_clustered_index_size;
  369. /* approximate clustered index size in
  370. database pages */
  371. ulint stat_sum_of_other_index_sizes;
  372. /* other indexes in database pages */
  373. ibool           stat_initialized; /* TRUE if statistics have
  374. been calculated the first time
  375.         after database startup or table creation */
  376. ulint stat_modified_counter;
  377. /* when a row is inserted, updated, or deleted,
  378. we add 1 to this number; we calculate new
  379. estimates for the stat_... values for the
  380. table and the indexes at an interval of 2 GB
  381. or when about 1 / 16 of table has been
  382. modified; also when the estimate operation is
  383. called for MySQL SHOW TABLE STATUS; the
  384. counter is reset to zero at statistics
  385. calculation; this counter is not protected by
  386. any latch, because this is only used for
  387. heuristics */
  388. /*----------------------*/
  389. mutex_t autoinc_mutex;
  390. /* mutex protecting the autoincrement
  391. counter */
  392. ibool autoinc_inited;
  393. /* TRUE if the autoinc counter has been
  394. inited; MySQL gets the init value by executing
  395. SELECT MAX(auto inc column) */
  396. ib_longlong autoinc;/* autoinc counter value to give to the
  397. next inserted row */
  398. ulint magic_n;/* magic number */
  399. };
  400. #define DICT_TABLE_MAGIC_N 76333786
  401. #ifndef UNIV_NONINL
  402. #include "dict0mem.ic"
  403. #endif
  404. #endif