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

MySQL数据库

开发平台:

Visual C++

  1. /**********************************************************************
  2. Data dictionary memory object creation
  3. (c) 1996 Innobase Oy
  4. Created 1/8/1996 Heikki Tuuri
  5. ***********************************************************************/
  6. #include "dict0mem.h"
  7. #ifdef UNIV_NONINL
  8. #include "dict0mem.ic"
  9. #endif
  10. #include "rem0rec.h"
  11. #include "data0type.h"
  12. #include "mach0data.h"
  13. #include "dict0dict.h"
  14. #include "que0que.h"
  15. #include "pars0pars.h"
  16. #include "lock0lock.h"
  17. #define DICT_HEAP_SIZE 100 /* initial memory heap size when
  18. creating a table or index object */
  19. /**************************************************************************
  20. Creates a table memory object. */
  21. dict_table_t*
  22. dict_mem_table_create(
  23. /*==================*/
  24. /* out, own: table object */
  25. const char* name, /* in: table name */
  26. ulint space, /* in: space where the clustered index of
  27. the table is placed; this parameter is
  28. ignored if the table is made a member of
  29. a cluster */
  30. ulint n_cols) /* in: number of columns */
  31. {
  32. dict_table_t* table;
  33. mem_heap_t* heap;
  34. ut_ad(name);
  35. heap = mem_heap_create(DICT_HEAP_SIZE);
  36. table = mem_heap_alloc(heap, sizeof(dict_table_t));
  37. table->heap = heap;
  38. table->type = DICT_TABLE_ORDINARY;
  39. table->name = mem_heap_strdup(heap, name);
  40. table->dir_path_of_temp_table = NULL;
  41. table->space = space;
  42. table->ibd_file_missing = FALSE;
  43. table->tablespace_discarded = FALSE;
  44. table->n_def = 0;
  45. table->n_cols = n_cols + DATA_N_SYS_COLS;
  46. table->mem_fix = 0;
  47. table->n_mysql_handles_opened = 0;
  48. table->n_foreign_key_checks_running = 0;
  49. table->cached = FALSE;
  50. table->mix_id = ut_dulint_zero;
  51. table->mix_len = 0;
  52. table->cols = mem_heap_alloc(heap, (n_cols + DATA_N_SYS_COLS)
  53. * sizeof(dict_col_t));
  54. UT_LIST_INIT(table->indexes);
  55. table->auto_inc_lock = mem_heap_alloc(heap, lock_get_size());
  56. table->query_cache_inv_trx_id = ut_dulint_zero;
  57. UT_LIST_INIT(table->locks);
  58. UT_LIST_INIT(table->foreign_list);
  59. UT_LIST_INIT(table->referenced_list);
  60. table->does_not_fit_in_memory = FALSE;
  61. table->stat_initialized = FALSE;
  62. table->stat_modified_counter = 0;
  63. mutex_create(&(table->autoinc_mutex));
  64. mutex_set_level(&(table->autoinc_mutex), SYNC_DICT_AUTOINC_MUTEX);
  65. table->autoinc_inited = FALSE;
  66. table->magic_n = DICT_TABLE_MAGIC_N;
  67. return(table);
  68. }
  69. /**************************************************************************
  70. Creates a cluster memory object. */
  71. dict_table_t*
  72. dict_mem_cluster_create(
  73. /*====================*/
  74. /* out, own: cluster object */
  75. const char* name, /* in: cluster name */
  76. ulint space, /* in: space where the clustered indexes
  77. of the member tables are placed */
  78. ulint n_cols, /* in: number of columns */
  79. ulint mix_len)/* in: length of the common key prefix in the
  80. cluster */
  81. {
  82. dict_table_t* cluster;
  83. cluster = dict_mem_table_create(name, space, n_cols);
  84. cluster->type = DICT_TABLE_CLUSTER;
  85. cluster->mix_len = mix_len;
  86. return(cluster);
  87. }
  88. /**************************************************************************
  89. Declares a non-published table as a member in a cluster. */
  90. void
  91. dict_mem_table_make_cluster_member(
  92. /*===============================*/
  93. dict_table_t* table, /* in: non-published table */
  94. const char* cluster_name) /* in: cluster name */
  95. {
  96. table->type = DICT_TABLE_CLUSTER_MEMBER;
  97. table->cluster_name = cluster_name;
  98. }
  99. /**************************************************************************
  100. Adds a column definition to a table. */
  101. void
  102. dict_mem_table_add_col(
  103. /*===================*/
  104. dict_table_t* table, /* in: table */
  105. const char* name, /* in: column name */
  106. ulint mtype, /* in: main datatype */
  107. ulint prtype, /* in: precise type */
  108. ulint len, /* in: length */
  109. ulint prec) /* in: precision */
  110. {
  111. dict_col_t* col;
  112. dtype_t* type;
  113. ut_ad(table && name);
  114. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  115. table->n_def++;
  116. col = dict_table_get_nth_col(table, table->n_def - 1);
  117. col->ind = table->n_def - 1;
  118. col->name = mem_heap_strdup(table->heap, name);
  119. col->table = table;
  120. col->ord_part = 0;
  121. col->clust_pos = ULINT_UNDEFINED;
  122. type = dict_col_get_type(col);
  123. dtype_set(type, mtype, prtype, len, prec);
  124. }
  125. /**************************************************************************
  126. Creates an index memory object. */
  127. dict_index_t*
  128. dict_mem_index_create(
  129. /*==================*/
  130. /* out, own: index object */
  131. const char* table_name, /* in: table name */
  132. const char* index_name, /* in: index name */
  133. ulint space, /* in: space where the index tree is
  134. placed, ignored if the index is of
  135. the clustered type */
  136. ulint type, /* in: DICT_UNIQUE,
  137. DICT_CLUSTERED, ... ORed */
  138. ulint n_fields) /* in: number of fields */
  139. {
  140. dict_index_t* index;
  141. mem_heap_t* heap;
  142. ut_ad(table_name && index_name);
  143. heap = mem_heap_create(DICT_HEAP_SIZE);
  144. index = mem_heap_alloc(heap, sizeof(dict_index_t));
  145. index->heap = heap;
  146. index->type = type;
  147. index->space = space;
  148. index->name = mem_heap_strdup(heap, index_name);
  149. index->table_name = table_name;
  150. index->table = NULL;
  151. index->n_def = 0;
  152. index->n_fields = n_fields;
  153. index->fields = mem_heap_alloc(heap, 1 + n_fields
  154. * sizeof(dict_field_t));
  155. /* The '1 +' above prevents allocation
  156. of an empty mem block */
  157. index->stat_n_diff_key_vals = NULL;
  158. index->cached = FALSE;
  159. index->magic_n = DICT_INDEX_MAGIC_N;
  160. return(index);
  161. }
  162. /**************************************************************************
  163. Creates and initializes a foreign constraint memory object. */
  164. dict_foreign_t*
  165. dict_mem_foreign_create(void)
  166. /*=========================*/
  167. /* out, own: foreign constraint struct */
  168. {
  169. dict_foreign_t* foreign;
  170. mem_heap_t* heap;
  171. heap = mem_heap_create(100);
  172. foreign = mem_heap_alloc(heap, sizeof(dict_foreign_t));
  173. foreign->heap = heap;
  174. foreign->id = NULL;
  175. foreign->type = 0;
  176. foreign->foreign_table_name = NULL;
  177. foreign->foreign_table = NULL;
  178. foreign->foreign_col_names = NULL;
  179. foreign->referenced_table_name = NULL;
  180. foreign->referenced_table = NULL;
  181. foreign->referenced_col_names = NULL;
  182. foreign->n_fields = 0;
  183. foreign->foreign_index = NULL;
  184. foreign->referenced_index = NULL;
  185. return(foreign);
  186. }
  187. /**************************************************************************
  188. Adds a field definition to an index. NOTE: does not take a copy
  189. of the column name if the field is a column. The memory occupied
  190. by the column name may be released only after publishing the index. */
  191. void
  192. dict_mem_index_add_field(
  193. /*=====================*/
  194. dict_index_t* index, /* in: index */
  195. const char* name, /* in: column name */
  196. ulint order, /* in: order criterion; 0 means an
  197. ascending order */
  198. ulint prefix_len) /* in: 0 or the column prefix length
  199. in a MySQL index like
  200. INDEX (textcol(25)) */
  201. {
  202. dict_field_t* field;
  203. ut_ad(index && name);
  204. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  205. index->n_def++;
  206. field = dict_index_get_nth_field(index, index->n_def - 1);
  207. field->name = name;
  208. field->order = order;
  209. field->prefix_len = prefix_len;
  210. }
  211. /**************************************************************************
  212. Frees an index memory object. */
  213. void
  214. dict_mem_index_free(
  215. /*================*/
  216. dict_index_t* index) /* in: index */
  217. {
  218. mem_heap_free(index->heap);
  219. }