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

MySQL数据库

开发平台:

Visual C++

  1. /**********************************************************************
  2. Data dictionary system
  3. (c) 1996 Innobase Oy
  4. Created 1/8/1996 Heikki Tuuri
  5. ***********************************************************************/
  6. #include "dict0load.h"
  7. #include "trx0undo.h"
  8. #include "trx0sys.h"
  9. #include "rem0rec.h"
  10. /*************************************************************************
  11. Gets the column data type. */
  12. UNIV_INLINE
  13. dtype_t*
  14. dict_col_get_type(
  15. /*==============*/
  16. dict_col_t* col)
  17. {
  18. ut_ad(col);
  19. return(&col->type);
  20. }
  21. /*************************************************************************
  22. Gets the column number. */
  23. UNIV_INLINE
  24. ulint
  25. dict_col_get_no(
  26. /*============*/
  27. dict_col_t* col)
  28. {
  29. ut_ad(col);
  30. return(col->ind);
  31. }
  32. /*************************************************************************
  33. Gets the column position in the clustered index. */
  34. UNIV_INLINE
  35. ulint
  36. dict_col_get_clust_pos(
  37. /*===================*/
  38. dict_col_t* col)
  39. {
  40. ut_ad(col);
  41. return(col->clust_pos);
  42. }
  43. /************************************************************************
  44. Gets the first index on the table (the clustered index). */
  45. UNIV_INLINE
  46. dict_index_t*
  47. dict_table_get_first_index(
  48. /*=======================*/
  49. /* out: index, NULL if none exists */
  50. dict_table_t* table) /* in: table */
  51. {
  52. ut_ad(table);
  53. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  54. return(UT_LIST_GET_FIRST(table->indexes));
  55. }
  56. /************************************************************************
  57. Gets the next index on the table. */
  58. UNIV_INLINE
  59. dict_index_t*
  60. dict_table_get_next_index(
  61. /*======================*/
  62. /* out: index, NULL if none left */
  63. dict_index_t* index) /* in: index */
  64. {
  65. ut_ad(index);
  66. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  67. return(UT_LIST_GET_NEXT(indexes, index));
  68. }
  69. /************************************************************************
  70. Gets the number of user-defined columns in a table in the dictionary
  71. cache. */
  72. UNIV_INLINE
  73. ulint
  74. dict_table_get_n_user_cols(
  75. /*=======================*/
  76. /* out: number of user-defined (e.g., not
  77. ROW_ID) columns of a table */
  78. dict_table_t* table) /* in: table */
  79. {
  80. ut_ad(table);
  81. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  82. ut_ad(table->cached);
  83. return(table->n_cols - DATA_N_SYS_COLS);
  84. }
  85. /************************************************************************
  86. Gets the number of system columns in a table in the dictionary cache. */
  87. UNIV_INLINE
  88. ulint
  89. dict_table_get_n_sys_cols(
  90. /*======================*/
  91. /* out: number of system (e.g.,
  92. ROW_ID) columns of a table */
  93. dict_table_t* table __attribute__((unused))) /* in: table */
  94. {
  95. ut_ad(table);
  96. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  97. ut_ad(table->cached);
  98. return(DATA_N_SYS_COLS);
  99. }
  100. /************************************************************************
  101. Gets the number of all columns (also system) in a table in the dictionary
  102. cache. */
  103. UNIV_INLINE
  104. ulint
  105. dict_table_get_n_cols(
  106. /*==================*/
  107. /* out: number of columns of a table */
  108. dict_table_t* table) /* in: table */
  109. {
  110. ut_ad(table);
  111. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  112. ut_ad(table->cached);
  113. return(table->n_cols);
  114. }
  115. /************************************************************************
  116. Gets the nth column of a table. */
  117. UNIV_INLINE
  118. dict_col_t*
  119. dict_table_get_nth_col(
  120. /*===================*/
  121. /* out: pointer to column object */
  122. dict_table_t* table, /* in: table */
  123. ulint pos) /* in: position of column */
  124. {
  125. ut_ad(table);
  126. ut_ad(pos < table->n_def);
  127. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  128. return((table->cols) + pos);
  129. }
  130. /************************************************************************
  131. Gets the given system column of a table. */
  132. UNIV_INLINE
  133. dict_col_t*
  134. dict_table_get_sys_col(
  135. /*===================*/
  136. /* out: pointer to column object */
  137. dict_table_t* table, /* in: table */
  138. ulint sys) /* in: DATA_ROW_ID, ... */
  139. {
  140. dict_col_t* col;
  141. ut_ad(table);
  142. ut_ad(sys < DATA_N_SYS_COLS);
  143. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  144. col = dict_table_get_nth_col(table, table->n_cols 
  145.    - DATA_N_SYS_COLS + sys);
  146. ut_ad(col->type.mtype == DATA_SYS);
  147. ut_ad(col->type.prtype == sys);
  148. return(col);
  149. }
  150. /************************************************************************
  151. Gets the given system column number of a table. */
  152. UNIV_INLINE
  153. ulint
  154. dict_table_get_sys_col_no(
  155. /*======================*/
  156. /* out: column number */
  157. dict_table_t* table, /* in: table */
  158. ulint sys) /* in: DATA_ROW_ID, ... */
  159. {
  160. ut_ad(table);
  161. ut_ad(sys < DATA_N_SYS_COLS);
  162. ut_ad(table->magic_n == DICT_TABLE_MAGIC_N);
  163. return(table->n_cols - DATA_N_SYS_COLS + sys);
  164. }
  165. /************************************************************************
  166. Gets the number of fields in the internal representation of an index,
  167. including fields added by the dictionary system. */
  168. UNIV_INLINE
  169. ulint
  170. dict_index_get_n_fields(
  171. /*====================*/
  172. /* out: number of fields */
  173. dict_index_t* index) /* in: an internal representation of index
  174. (in the dictionary cache) */
  175. {
  176. ut_ad(index);
  177. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  178. return(index->n_fields);
  179. }
  180. /************************************************************************
  181. Gets the number of fields in the internal representation of an index
  182. that uniquely determine the position of an index entry in the index, if
  183. we do not take multiversioning into account: in the B-tree use the value
  184. returned by dict_index_get_n_unique_in_tree. */
  185. UNIV_INLINE
  186. ulint
  187. dict_index_get_n_unique(
  188. /*====================*/
  189. /* out: number of fields */
  190. dict_index_t* index) /* in: an internal representation of index
  191. (in the dictionary cache) */
  192. {
  193. ut_ad(index);
  194. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  195. ut_ad(index->cached);
  196. return(index->n_uniq);
  197. }
  198. /************************************************************************
  199. Gets the number of fields in the internal representation of an index
  200. which uniquely determine the position of an index entry in the index, if
  201. we also take multiversioning into account. */
  202. UNIV_INLINE
  203. ulint
  204. dict_index_get_n_unique_in_tree(
  205. /*============================*/
  206. /* out: number of fields */
  207. dict_index_t* index) /* in: an internal representation of index
  208. (in the dictionary cache) */
  209. {
  210. ut_ad(index);
  211. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  212. ut_ad(index->cached);
  213. if (index->type & DICT_CLUSTERED) {
  214. return(dict_index_get_n_unique(index));
  215. }
  216. return(dict_index_get_n_fields(index));
  217. }
  218. /************************************************************************
  219. Gets the number of user-defined ordering fields in the index. In the internal
  220. representation of clustered indexes we add the row id to the ordering fields
  221. to make a clustered index unique, but this function returns the number of
  222. fields the user defined in the index as ordering fields. */
  223. UNIV_INLINE
  224. ulint
  225. dict_index_get_n_ordering_defined_by_user(
  226. /*======================================*/
  227. /* out: number of fields */
  228. dict_index_t* index) /* in: an internal representation of index
  229. (in the dictionary cache) */
  230. {
  231. return(index->n_user_defined_cols);
  232. }
  233. /************************************************************************
  234. Gets the nth field of an index. */
  235. UNIV_INLINE
  236. dict_field_t*
  237. dict_index_get_nth_field(
  238. /*=====================*/
  239. /* out: pointer to field object */
  240. dict_index_t* index, /* in: index */
  241. ulint pos) /* in: position of field */
  242. {
  243. ut_ad(index);
  244. ut_ad(pos < index->n_def);
  245. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  246. return((index->fields) + pos);
  247. }
  248. /************************************************************************
  249. Returns the position of a system column in an index. */
  250. UNIV_INLINE
  251. ulint
  252. dict_index_get_sys_col_pos(
  253. /*=======================*/
  254. /* out: position, ULINT_UNDEFINED if not
  255. contained */
  256. dict_index_t* index, /* in: index */
  257. ulint type) /* in: DATA_ROW_ID, ... */
  258. {
  259. dict_col_t* col;
  260. ut_ad(index);
  261. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  262. ut_ad(!(index->type & DICT_UNIVERSAL));
  263. col = dict_table_get_sys_col(index->table, type);
  264. if (index->type & DICT_CLUSTERED) {
  265. return(col->clust_pos);
  266. }
  267. return(dict_index_get_nth_col_pos(index,
  268. dict_table_get_sys_col_no(index->table, type)));
  269. }
  270. /************************************************************************
  271. Gets the value of a system column in a clustered index record. The clustered
  272. index must contain the system column: if the index is unique, row id is
  273. not contained there! */
  274. UNIV_INLINE
  275. dulint
  276. dict_index_rec_get_sys_col(
  277. /*=======================*/
  278. /* out: system column value */
  279. dict_index_t* index, /* in: clustered index describing the record */
  280. ulint type, /* in: column type: DATA_ROLL_PTR, ... */
  281. rec_t* rec) /* in: record */
  282. {
  283. ulint pos;
  284. byte* field;
  285. ulint len;
  286. ut_ad(index);
  287. ut_ad(index->type & DICT_CLUSTERED);
  288. pos = dict_index_get_sys_col_pos(index, type);
  289. ut_ad(pos != ULINT_UNDEFINED);
  290. field = rec_get_nth_field(rec, pos, &len);
  291. if (type == DATA_ROLL_PTR) {
  292. ut_ad(len == 7);
  293. return(trx_read_roll_ptr(field));
  294. } else if (type == DATA_TRX_ID) {
  295. return(trx_read_trx_id(field));
  296. } else if (type == DATA_MIX_ID) {
  297. return(mach_dulint_read_compressed(field));
  298. } else {
  299. ut_a(type == DATA_ROW_ID);
  300. return(mach_read_from_6(field));
  301. }
  302. }
  303. /*************************************************************************
  304. Gets the index tree where the index is stored. */
  305. UNIV_INLINE
  306. dict_tree_t*
  307. dict_index_get_tree(
  308. /*================*/
  309. /* out: index tree */
  310. dict_index_t* index) /* in: index */
  311. {
  312. ut_ad(index);
  313. ut_ad(index->magic_n == DICT_INDEX_MAGIC_N);
  314. return(index->tree);
  315. }
  316. /*************************************************************************
  317. Gets the field order criterion. */
  318. UNIV_INLINE
  319. ulint
  320. dict_field_get_order(
  321. /*=================*/
  322. dict_field_t* field)
  323. {
  324. ut_ad(field);
  325. return(field->order);
  326. }
  327. /*************************************************************************
  328. Gets the field column. */
  329. UNIV_INLINE
  330. dict_col_t*
  331. dict_field_get_col(
  332. /*===============*/
  333. dict_field_t* field)
  334. {
  335. ut_ad(field);
  336. return(field->col);
  337. }
  338. /************************************************************************
  339. Gets pointer to the nth field data type in an index. */
  340. UNIV_INLINE
  341. dtype_t*
  342. dict_index_get_nth_type(
  343. /*====================*/
  344. /* out: data type */
  345. dict_index_t* index, /* in: index */
  346. ulint pos) /* in: position of the field */
  347. {
  348. return(dict_col_get_type(dict_field_get_col(
  349. dict_index_get_nth_field(index, pos))));
  350. }
  351. /************************************************************************
  352. Gets the column number the nth field in an index. */
  353. UNIV_INLINE
  354. ulint
  355. dict_index_get_nth_col_no(
  356. /*======================*/
  357. /* out: column number */
  358. dict_index_t* index, /* in: index */
  359. ulint pos) /* in: position of the field */
  360. {
  361. return(dict_col_get_no(dict_field_get_col(
  362. dict_index_get_nth_field(index, pos))));
  363. }
  364. /*************************************************************************
  365. Gets the space id of the root of the index tree. */
  366. UNIV_INLINE
  367. ulint
  368. dict_tree_get_space(
  369. /*================*/
  370. /* out: space id */
  371. dict_tree_t* tree) /* in: tree */
  372. {
  373. ut_ad(tree);
  374. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  375. return(tree->space);
  376. }
  377. /*************************************************************************
  378. Sets the space id of the root of the index tree. */
  379. UNIV_INLINE
  380. void
  381. dict_tree_set_space(
  382. /*================*/
  383. dict_tree_t* tree, /* in: tree */
  384. ulint space) /* in: space id */
  385. {
  386. ut_ad(tree);
  387. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  388. tree->space = space;
  389. }
  390. /*************************************************************************
  391. Gets the page number of the root of the index tree. */
  392. UNIV_INLINE
  393. ulint
  394. dict_tree_get_page(
  395. /*===============*/
  396. /* out: page number */
  397. dict_tree_t* tree) /* in: tree */
  398. {
  399. ut_ad(tree);
  400. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  401. return(tree->page);
  402. }
  403. /*************************************************************************
  404. Sets the page number of the root of index tree. */
  405. UNIV_INLINE
  406. void
  407. dict_tree_set_page(
  408. /*===============*/
  409. dict_tree_t* tree, /* in: tree */
  410. ulint page) /* in: page number */
  411. {
  412. ut_ad(tree);
  413. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  414. tree->page = page;
  415. }
  416. /*************************************************************************
  417. Gets the type of the index tree. */
  418. UNIV_INLINE
  419. ulint
  420. dict_tree_get_type(
  421. /*===============*/
  422. /* out: type */
  423. dict_tree_t* tree) /* in: tree */
  424. {
  425. ut_ad(tree);
  426. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  427. return(tree->type);
  428. }
  429. /*************************************************************************
  430. Gets the read-write lock of the index tree. */
  431. UNIV_INLINE
  432. rw_lock_t*
  433. dict_tree_get_lock(
  434. /*===============*/
  435. /* out: read-write lock */
  436. dict_tree_t* tree) /* in: tree */
  437. {
  438. ut_ad(tree);
  439. ut_ad(tree->magic_n == DICT_TREE_MAGIC_N);
  440. return(&(tree->lock));
  441. }
  442. /************************************************************************
  443. Returns free space reserved for future updates of records. This is
  444. relevant only in the case of many consecutive inserts, as updates
  445. which make the records bigger might fragment the index. */
  446. UNIV_INLINE
  447. ulint
  448. dict_tree_get_space_reserve(
  449. /*========================*/
  450. /* out: number of free bytes on page,
  451. reserved for updates */
  452. dict_tree_t* tree) /* in: a tree */
  453. {
  454. ut_ad(tree);
  455. UT_NOT_USED(tree);
  456. return(UNIV_PAGE_SIZE / 16);
  457. }
  458. /**************************************************************************
  459. Checks if a table is in the dictionary cache. */
  460. UNIV_INLINE
  461. dict_table_t*
  462. dict_table_check_if_in_cache_low(
  463. /*==============================*/
  464. /* out: table, NULL if not found */
  465. const char* table_name) /* in: table name */
  466. {
  467. dict_table_t* table;
  468. ulint table_fold;
  469. ut_ad(table_name);
  470. #ifdef UNIV_SYNC_DEBUG
  471. ut_ad(mutex_own(&(dict_sys->mutex)));
  472. #endif /* UNIV_SYNC_DEBUG */
  473. /* Look for the table name in the hash table */
  474. table_fold = ut_fold_string(table_name);
  475. HASH_SEARCH(name_hash, dict_sys->table_hash, table_fold, table,
  476. ut_strcmp(table->name, table_name) == 0);
  477. return(table);
  478. }
  479. /**************************************************************************
  480. Gets a table; loads it to the dictionary cache if necessary. A low-level
  481. function. */
  482. UNIV_INLINE
  483. dict_table_t*
  484. dict_table_get_low(
  485. /*===============*/
  486. /* out: table, NULL if not found */
  487. const char* table_name) /* in: table name */
  488. {
  489. dict_table_t* table;
  490. ut_ad(table_name);
  491. #ifdef UNIV_SYNC_DEBUG
  492. ut_ad(mutex_own(&(dict_sys->mutex)));
  493. #endif /* UNIV_SYNC_DEBUG */
  494. table = dict_table_check_if_in_cache_low(table_name);
  495. if (table == NULL) {
  496. table = dict_load_table(table_name);
  497. }
  498. return(table);
  499. }
  500. /**************************************************************************
  501. Returns a table object, based on table id, and memoryfixes it. */
  502. UNIV_INLINE
  503. dict_table_t*
  504. dict_table_get_on_id_low(
  505. /*=====================*/
  506. /* out: table, NULL if does not exist */
  507. dulint table_id, /* in: table id */
  508. trx_t* trx) /* in: transaction handle */
  509. {
  510. dict_table_t* table;
  511. ulint fold;
  512. #ifdef UNIV_SYNC_DEBUG
  513. ut_ad(mutex_own(&(dict_sys->mutex)));
  514. #endif /* UNIV_SYNC_DEBUG */
  515. UT_NOT_USED(trx);
  516. /* Look for the table name in the hash table */
  517. fold = ut_fold_dulint(table_id);
  518. HASH_SEARCH(id_hash, dict_sys->table_id_hash, fold, table,
  519. ut_dulint_cmp(table->id, table_id) == 0);
  520. if (table == NULL) {
  521. table = dict_load_table_on_id(table_id);
  522. }
  523. if (table != NULL) {
  524. table->mem_fix++;
  525. /* lock_push(trx, table, LOCK_DICT_MEM_FIX) */
  526. }
  527. /* TODO: should get the type information from MySQL */
  528. return(table);
  529. }
  530. /**************************************************************************
  531. Releases a table from being memoryfixed. Currently this has no relevance. */
  532. UNIV_INLINE
  533. void
  534. dict_table_release(
  535. /*===============*/
  536. dict_table_t* table) /* in: table to be released */
  537. {
  538. mutex_enter(&(dict_sys->mutex));
  539. table->mem_fix--;
  540. mutex_exit(&(dict_sys->mutex));
  541. }
  542. /**************************************************************************
  543. Returns an index object. */
  544. UNIV_INLINE
  545. dict_index_t*
  546. dict_table_get_index(
  547. /*=================*/
  548. /* out: index, NULL if does not exist */
  549. dict_table_t* table, /* in: table */
  550. const char* name) /* in: index name */
  551. {
  552. dict_index_t* index = NULL;
  553. index = dict_table_get_first_index(table);
  554. while (index != NULL) {
  555. if (ut_strcmp(name, index->name) == 0) {
  556. break;
  557. }
  558. index = dict_table_get_next_index(index);
  559. }
  560. return(index);
  561. }
  562. /***********************************************************************
  563. Checks if a table which is a mixed cluster member owns a record. */
  564. UNIV_INLINE
  565. ibool
  566. dict_is_mixed_table_rec(
  567. /*====================*/
  568. /* out: TRUE if the record belongs to this
  569. table */
  570. dict_table_t* table, /* in: table in a mixed cluster */
  571. rec_t* rec) /* in: user record in the clustered index */
  572. {
  573. byte* mix_id_field;
  574. ulint len;
  575. mix_id_field = rec_get_nth_field(rec, table->mix_len, &len);
  576. if ((len != table->mix_id_len)
  577.     || (0 != ut_memcmp(table->mix_id_buf, mix_id_field, len))) {
  578. return(FALSE);
  579. }
  580. return(TRUE);
  581. }