开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
row0purge.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：15k
源码类别：

MySQL数据库

开发平台：

Visual C++

row0purge.c：源码内容
  1. /******************************************************
  2. Purge obsolete records
  4. (c) 1997 Innobase Oy
  6. Created 3/14/1997 Heikki Tuuri
  7. *******************************************************/
  9. #include "row0purge.h"
  11. #ifdef UNIV_NONINL
  12. #include "row0purge.ic"
  13. #endif
  15. #include "fsp0fsp.h"
  16. #include "mach0data.h"
  17. #include "trx0rseg.h"
  18. #include "trx0trx.h"
  19. #include "trx0roll.h"
  20. #include "trx0undo.h"
  21. #include "trx0purge.h"
  22. #include "trx0rec.h"
  23. #include "que0que.h"
  24. #include "row0row.h"
  25. #include "row0upd.h"
  26. #include "row0vers.h"
  27. #include "row0mysql.h"
  28. #include "log0log.h"
  30. /************************************************************************
  31. Creates a purge node to a query graph. */
  33. purge_node_t*
  34. row_purge_node_create(
  35. /*==================*/
  36. /* out, own: purge node */
  37. que_thr_t* parent, /* in: parent node, i.e., a thr node */
  38. mem_heap_t* heap) /* in: memory heap where created */
  39. {
  40. purge_node_t* node;
  42. ut_ad(parent && heap);
  44. node = mem_heap_alloc(heap, sizeof(purge_node_t));
  46. node->common.type = QUE_NODE_PURGE;
  47. node->common.parent = parent;
  49. node->heap = mem_heap_create(256);
  51. return(node);
  52. }
  54. /***************************************************************
  55. Repositions the pcur in the purge node on the clustered index record,
  56. if found. */
  57. static
  58. ibool
  59. row_purge_reposition_pcur(
  60. /*======================*/
  61. /* out: TRUE if the record was found */
  62. ulint mode, /* in: latching mode */
  63. purge_node_t* node, /* in: row purge node */
  64. mtr_t* mtr) /* in: mtr */
  65. {
  66. ibool found;
  68. if (node->found_clust) {
  69. found = btr_pcur_restore_position(mode, &(node->pcur), mtr);
  71. return(found);
  72. }
  74. found = row_search_on_row_ref(&(node->pcur), mode, node->table,
  75. node->ref, mtr);
  76. node->found_clust = found;
  78. if (found) {
  79. btr_pcur_store_position(&(node->pcur), mtr);
  80. }
  82. return(found);
  83. }
  85. /***************************************************************
  86. Removes a delete marked clustered index record if possible. */
  87. static
  88. ibool
  89. row_purge_remove_clust_if_poss_low(
  90. /*===============================*/
  91. /* out: TRUE if success, or if not found, or
  92. if modified after the delete marking */
  93. purge_node_t* node, /* in: row purge node */
  94. ulint mode) /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE */
  95. {
  96. dict_index_t* index;
  97. btr_pcur_t* pcur;
  98. btr_cur_t* btr_cur;
  99. ibool success;
  100. ulint err;
  101. mtr_t mtr;
  103. index = dict_table_get_first_index(node->table);
  105. pcur = &(node->pcur);
  106. btr_cur = btr_pcur_get_btr_cur(pcur);
  108. mtr_start(&mtr);
  110. success = row_purge_reposition_pcur(mode, node, &mtr);
  112. if (!success) {
  113. /* The record is already removed */
  115. btr_pcur_commit_specify_mtr(pcur, &mtr);
  117. return(TRUE);
  118. }
  120. if (0 != ut_dulint_cmp(node->roll_ptr,
  121. row_get_rec_roll_ptr(btr_pcur_get_rec(pcur), index))) {
  123. /* Someone else has modified the record later: do not remove */
  124. btr_pcur_commit_specify_mtr(pcur, &mtr);
  126. return(TRUE);
  127. }
  129. if (mode == BTR_MODIFY_LEAF) {
  130. success = btr_cur_optimistic_delete(btr_cur, &mtr);
  131. } else {
  132. ut_ad(mode == BTR_MODIFY_TREE);
  133. btr_cur_pessimistic_delete(&err, FALSE, btr_cur, FALSE, &mtr);
  135. if (err == DB_SUCCESS) {
  136. success = TRUE;
  137. } else if (err == DB_OUT_OF_FILE_SPACE) {
  138. success = FALSE;
  139. } else {
  140. ut_error;
  141. }
  142. }
  144. btr_pcur_commit_specify_mtr(pcur, &mtr);
  146. return(success);
  147. }
  149. /***************************************************************
  150. Removes a clustered index record if it has not been modified after the delete
  151. marking. */
  152. static
  153. void
  154. row_purge_remove_clust_if_poss(
  155. /*===========================*/
  156. purge_node_t* node) /* in: row purge node */
  157. {
  158. ibool success;
  159. ulint n_tries = 0;
  161. /* fputs("Purge: Removing clustered recordn", stderr); */
  163. success = row_purge_remove_clust_if_poss_low(node, BTR_MODIFY_LEAF);
  164. if (success) {
  166. return;
  167. }
  168. retry:
  169. success = row_purge_remove_clust_if_poss_low(node, BTR_MODIFY_TREE);
  170. /* The delete operation may fail if we have little
  171. file space left: TODO: easiest to crash the database
  172. and restart with more file space */
  174. if (!success && n_tries < BTR_CUR_RETRY_DELETE_N_TIMES) {
  175. n_tries++;
  177. os_thread_sleep(BTR_CUR_RETRY_SLEEP_TIME);
  179. goto retry;
  180. }
  182. ut_a(success);
  183. }
  184.  
  185. /***************************************************************
  186. Removes a secondary index entry if possible. */
  187. static
  188. ibool
  189. row_purge_remove_sec_if_poss_low(
  190. /*=============================*/
  191. /* out: TRUE if success or if not found */
  192. purge_node_t* node, /* in: row purge node */
  193. dict_index_t* index, /* in: index */
  194. dtuple_t* entry, /* in: index entry */
  195. ulint mode) /* in: latch mode BTR_MODIFY_LEAF or
  196. BTR_MODIFY_TREE */
  197. {
  198. btr_pcur_t pcur;
  199. btr_cur_t* btr_cur;
  200. ibool success;
  201. ibool old_has = 0; /* remove warning */
  202. ibool found;
  203. ulint err;
  204. mtr_t mtr;
  205. mtr_t* mtr_vers;
  207. log_free_check();
  208. mtr_start(&mtr);
  210. found = row_search_index_entry(index, entry, mode, &pcur, &mtr);
  212. if (!found) {
  213. /* Not found */
  215. /* fputs("PURGE:........sec entry not foundn", stderr); */
  216. /* dtuple_print(entry); */
  218. btr_pcur_close(&pcur);
  219. mtr_commit(&mtr);
  221. return(TRUE);
  222. }
  224. btr_cur = btr_pcur_get_btr_cur(&pcur);
  226. /* We should remove the index record if no later version of the row,
  227. which cannot be purged yet, requires its existence. If some requires,
  228. we should do nothing. */
  230. mtr_vers = mem_alloc(sizeof(mtr_t));
  232. mtr_start(mtr_vers);
  234. success = row_purge_reposition_pcur(BTR_SEARCH_LEAF, node, mtr_vers);
  236. if (success) {
  237. old_has = row_vers_old_has_index_entry(TRUE,
  238. btr_pcur_get_rec(&(node->pcur)),
  239. mtr_vers, index, entry);
  240. }
  242. btr_pcur_commit_specify_mtr(&(node->pcur), mtr_vers);
  244. mem_free(mtr_vers);
  246. if (!success || !old_has) {
  247. /* Remove the index record */
  249. if (mode == BTR_MODIFY_LEAF) {
  250. success = btr_cur_optimistic_delete(btr_cur, &mtr);
  251. } else {
  252. ut_ad(mode == BTR_MODIFY_TREE);
  253. btr_cur_pessimistic_delete(&err, FALSE, btr_cur,
  254. FALSE, &mtr);
  255. if (err == DB_SUCCESS) {
  256. success = TRUE;
  257. } else if (err == DB_OUT_OF_FILE_SPACE) {
  258. success = FALSE;
  259. } else {
  260. ut_error;
  261. }
  262. }
  263. }
  265. btr_pcur_close(&pcur);
  266. mtr_commit(&mtr);
  268. return(success);
  269. }
  271. /***************************************************************
  272. Removes a secondary index entry if possible. */
  273. UNIV_INLINE
  274. void
  275. row_purge_remove_sec_if_poss(
  276. /*=========================*/
  277. purge_node_t* node, /* in: row purge node */
  278. dict_index_t* index, /* in: index */
  279. dtuple_t* entry) /* in: index entry */
  280. {
  281. ibool success;
  282. ulint n_tries = 0;
  284. /* fputs("Purge: Removing secondary recordn", stderr); */
  286. success = row_purge_remove_sec_if_poss_low(node, index, entry,
  287. BTR_MODIFY_LEAF);
  288. if (success) {
  290. return;
  291. }
  292. retry:
  293. success = row_purge_remove_sec_if_poss_low(node, index, entry,
  294. BTR_MODIFY_TREE);
  295. /* The delete operation may fail if we have little
  296. file space left: TODO: easiest to crash the database
  297. and restart with more file space */
  299. if (!success && n_tries < BTR_CUR_RETRY_DELETE_N_TIMES) {
  301. n_tries++;
  303. os_thread_sleep(BTR_CUR_RETRY_SLEEP_TIME);
  305. goto retry;
  306. }
  308. ut_a(success);
  309. }
  311. /***************************************************************
  312. Purges a delete marking of a record. */
  313. static
  314. void
  315. row_purge_del_mark(
  316. /*===============*/
  317. purge_node_t* node) /* in: row purge node */
  318. {
  319. mem_heap_t* heap;
  320. dtuple_t* entry;
  321. dict_index_t* index;
  323. ut_ad(node);
  325. heap = mem_heap_create(1024);
  327. while (node->index != NULL) {
  328. index = node->index;
  330. /* Build the index entry */
  331. entry = row_build_index_entry(node->row, index, heap);
  333. row_purge_remove_sec_if_poss(node, index, entry);
  335. node->index = dict_table_get_next_index(node->index);
  336. }
  338. mem_heap_free(heap);
  340. row_purge_remove_clust_if_poss(node);
  341. }
  343. /***************************************************************
  344. Purges an update of an existing record. Also purges an update of a delete
  345. marked record if that record contained an externally stored field. */
  346. static
  347. void
  348. row_purge_upd_exist_or_extern(
  349. /*==========================*/
  350. purge_node_t* node) /* in: row purge node */
  351. {
  352. mem_heap_t* heap;
  353. dtuple_t* entry;
  354. dict_index_t* index;
  355. upd_field_t* ufield;
  356. ibool is_insert;
  357. ulint rseg_id;
  358. ulint page_no;
  359. ulint offset;
  360. ulint internal_offset;
  361. byte* data_field;
  362. ulint data_field_len;
  363. ulint i;
  364. mtr_t mtr;
  366. ut_ad(node);
  368. if (node->rec_type == TRX_UNDO_UPD_DEL_REC) {
  370. goto skip_secondaries;
  371. }
  373. heap = mem_heap_create(1024);
  375. while (node->index != NULL) {
  376. index = node->index;
  378. if (row_upd_changes_ord_field_binary(NULL, node->index,
  379. node->update)) {
  380. /* Build the older version of the index entry */
  381. entry = row_build_index_entry(node->row, index, heap);
  383. row_purge_remove_sec_if_poss(node, index, entry);
  384. }
  386. node->index = dict_table_get_next_index(node->index);
  387. }
  389. mem_heap_free(heap);
  391. skip_secondaries:
  392. /* Free possible externally stored fields */
  393. for (i = 0; i < upd_get_n_fields(node->update); i++) {
  395. ufield = upd_get_nth_field(node->update, i);
  397. if (ufield->extern_storage) {
  398. /* We use the fact that new_val points to
  399. node->undo_rec and get thus the offset of
  400. dfield data inside the unod record. Then we
  401. can calculate from node->roll_ptr the file
  402. address of the new_val data */
  404. internal_offset = ((byte*)ufield->new_val.data)
  405. - node->undo_rec;
  407. ut_a(internal_offset < UNIV_PAGE_SIZE);
  409. trx_undo_decode_roll_ptr(node->roll_ptr,
  410. &is_insert, &rseg_id,
  411. &page_no, &offset);
  412. mtr_start(&mtr);
  414. /* We have to acquire an X-latch to the clustered
  415. index tree */
  417. index = dict_table_get_first_index(node->table);
  419. mtr_x_lock(dict_tree_get_lock(index->tree), &mtr);
  421. /* NOTE: we must also acquire an X-latch to the
  422. root page of the tree. We will need it when we
  423. free pages from the tree. If the tree is of height 1,
  424. the tree X-latch does NOT protect the root page,
  425. because it is also a leaf page. Since we will have a
  426. latch on an undo log page, we would break the
  427. latching order if we would only later latch the
  428. root page of such a tree! */
  430. btr_root_get(index->tree, &mtr);
  432. /* We assume in purge of externally stored fields
  433. that the space id of the undo log record is 0! */
  435. data_field = buf_page_get(0, page_no, RW_X_LATCH, &mtr)
  436.      + offset + internal_offset;
  438. #ifdef UNIV_SYNC_DEBUG
  439. buf_page_dbg_add_level(buf_frame_align(data_field),
  440. SYNC_TRX_UNDO_PAGE);
  441. #endif /* UNIV_SYNC_DEBUG */
  442.      
  443. data_field_len = ufield->new_val.len;
  445. btr_free_externally_stored_field(index, data_field,
  446. data_field_len, FALSE, &mtr);
  447. mtr_commit(&mtr);
  448. }
  449. }
  450. }
  452. /***************************************************************
  453. Parses the row reference and other info in a modify undo log record. */
  454. static
  455. ibool
  456. row_purge_parse_undo_rec(
  457. /*=====================*/
  458. /* out: TRUE if purge operation required:
  459. NOTE that then the CALLER must unfreeze
  460. data dictionary! */
  461. purge_node_t* node, /* in: row undo node */
  462. ibool* updated_extern,
  463. /* out: TRUE if an externally stored field
  464. was updated */
  465. que_thr_t* thr) /* in: query thread */
  466. {
  467. dict_index_t* clust_index;
  468. byte* ptr;
  469. trx_t* trx;
  470. dulint undo_no;
  471. dulint table_id;
  472. dulint trx_id;
  473. dulint roll_ptr;
  474. ulint info_bits;
  475. ulint type;
  476. ulint cmpl_info;
  478. ut_ad(node && thr);
  480. trx = thr_get_trx(thr);
  482. ptr = trx_undo_rec_get_pars(node->undo_rec, &type, &cmpl_info,
  483. updated_extern, &undo_no, &table_id);
  484. node->rec_type = type;
  486. if (type == TRX_UNDO_UPD_DEL_REC && !(*updated_extern)) {
  488. return(FALSE);
  489. }     
  491. ptr = trx_undo_update_rec_get_sys_cols(ptr, &trx_id, &roll_ptr,
  492. &info_bits);
  493. node->table = NULL;
  495. if (type == TRX_UNDO_UPD_EXIST_REC
  496.     && cmpl_info & UPD_NODE_NO_ORD_CHANGE && !(*updated_extern)) {
  498.      /* Purge requires no changes to indexes: we may return */
  500.      return(FALSE);
  501. }
  503. /* Prevent DROP TABLE etc. from running when we are doing the purge
  504. for this row */
  506. row_mysql_freeze_data_dictionary(trx);
  508. mutex_enter(&(dict_sys->mutex));
  510. node->table = dict_table_get_on_id_low(table_id, trx);
  512. mutex_exit(&(dict_sys->mutex));
  514. if (node->table == NULL) {
  515. /* The table has been dropped: no need to do purge */
  517. row_mysql_unfreeze_data_dictionary(trx);
  519. return(FALSE);
  520. }
  522. if (node->table->ibd_file_missing) {
  523. /* We skip purge of missing .ibd files */
  525. node->table = NULL;
  527. row_mysql_unfreeze_data_dictionary(trx);
  529. return(FALSE);
  530. }
  532. clust_index = dict_table_get_first_index(node->table);
  534. if (clust_index == NULL) {
  535. /* The table was corrupt in the data dictionary */
  537. row_mysql_unfreeze_data_dictionary(trx);
  539. return(FALSE);
  540. }
  542. ptr = trx_undo_rec_get_row_ref(ptr, clust_index, &(node->ref),
  543. node->heap);
  545. ptr = trx_undo_update_rec_get_update(ptr, clust_index, type, trx_id,
  546. roll_ptr, info_bits, trx,
  547. node->heap, &(node->update));
  549. /* Read to the partial row the fields that occur in indexes */
  551. if (!cmpl_info & UPD_NODE_NO_ORD_CHANGE) {
  552. ptr = trx_undo_rec_get_partial_row(ptr, clust_index,
  553. &(node->row), node->heap);
  554. }
  556. return(TRUE);
  557. }
  559. /***************************************************************
  560. Fetches an undo log record and does the purge for the recorded operation.
  561. If none left, or the current purge completed, returns the control to the
  562. parent node, which is always a query thread node. */
  563. static
  564. ulint
  565. row_purge(
  566. /*======*/
  567. /* out: DB_SUCCESS if operation successfully
  568. completed, else error code */
  569. purge_node_t* node, /* in: row purge node */
  570. que_thr_t* thr) /* in: query thread */
  571. {
  572. dulint roll_ptr;
  573. ibool purge_needed;
  574. ibool updated_extern;
  575. trx_t* trx;
  577. ut_ad(node && thr);
  579. trx = thr_get_trx(thr);
  581. node->undo_rec = trx_purge_fetch_next_rec(&roll_ptr,
  582. &(node->reservation),
  583. node->heap);
  584. if (!node->undo_rec) {
  585. /* Purge completed for this query thread */
  587. thr->run_node = que_node_get_parent(node);
  589. return(DB_SUCCESS);
  590. }
  592. node->roll_ptr = roll_ptr;
  594. if (node->undo_rec == &trx_purge_dummy_rec) {
  595. purge_needed = FALSE;
  596. } else {
  597. purge_needed = row_purge_parse_undo_rec(node, &updated_extern,
  598. thr);
  599. /* If purge_needed == TRUE, we must also remember to unfreeze
  600. data dictionary! */
  601. }
  603. if (purge_needed) {
  604. node->found_clust = FALSE;
  606. node->index = dict_table_get_next_index(
  607. dict_table_get_first_index(node->table));
  609. if (node->rec_type == TRX_UNDO_DEL_MARK_REC) {
  610. row_purge_del_mark(node);
  612. } else if (updated_extern
  613.     || node->rec_type == TRX_UNDO_UPD_EXIST_REC) {
  615. row_purge_upd_exist_or_extern(node);
  616. }
  618. if (node->found_clust) {
  619. btr_pcur_close(&(node->pcur));
  620. }
  622. row_mysql_unfreeze_data_dictionary(trx);
  623. }
  625. /* Do some cleanup */
  626. trx_purge_rec_release(node->reservation);
  627. mem_heap_empty(node->heap);
  629. thr->run_node = node;
  631. return(DB_SUCCESS);
  632. }
  634. /***************************************************************
  635. Does the purge operation for a single undo log record. This is a high-level
  636. function used in an SQL execution graph. */
  638. que_thr_t*
  639. row_purge_step(
  640. /*===========*/
  641. /* out: query thread to run next or NULL */
  642. que_thr_t* thr) /* in: query thread */
  643. {
  644. purge_node_t* node;
  645. ulint err;
  647. ut_ad(thr);
  649. node = thr->run_node;
  651. ut_ad(que_node_get_type(node) == QUE_NODE_PURGE);
  653. err = row_purge(node, thr);
  655. ut_ad(err == DB_SUCCESS);
  657. return(thr);
  658. }