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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
page0page.ic
资源名称：mysql-3.23.35.tar.gz　[点击查看]
上传用户：tsgydb
上传日期：2007-04-14
资源大小：10674k
文件大小：18k
源码类别：

MySQL数据库

开发平台：

Visual C++

page0page.ic：源码内容
  1. /******************************************************
  2. Index page routines
  4. (c) 1994-1996 Innobase Oy
  6. Created 2/2/1994 Heikki Tuuri
  7. *******************************************************/
  9. #include "mach0data.h"
  10. #include "rem0cmp.h"
  11. #include "mtr0log.h"
  13. #ifdef UNIV_MATERIALIZE
  14. #undef UNIV_INLINE
  15. #define UNIV_INLINE
  16. #endif
  18. /*****************************************************************
  19. Returns the max trx id field value. */
  20. UNIV_INLINE
  21. dulint
  22. page_get_max_trx_id(
  23. /*================*/
  24. page_t* page) /* in: page */
  25. {
  26. ut_ad(page);
  28. return(mach_read_from_8(page + PAGE_HEADER + PAGE_MAX_TRX_ID));
  29. }
  31. /*****************************************************************
  32. Sets the max trx id field value if trx_id is bigger than the previous
  33. value. */
  34. UNIV_INLINE
  35. void
  36. page_update_max_trx_id(
  37. /*===================*/
  38. page_t* page, /* in: page */
  39. dulint trx_id) /* in: transaction id */
  40. {
  41. ut_ad(page);
  43. if (ut_dulint_cmp(page_get_max_trx_id(page), trx_id) < 0) {
  45. page_set_max_trx_id(page, trx_id);
  46. }
  47. }
  49. /*****************************************************************
  50. Reads the given header field. */
  51. UNIV_INLINE
  52. ulint
  53. page_header_get_field(
  54. /*==================*/
  55. page_t* page, /* in: page */
  56. ulint field) /* in: PAGE_LEVEL, ... */
  57. {
  58. ut_ad(page);
  59. ut_ad(field <= PAGE_INDEX_ID);
  61. return(mach_read_from_2(page + PAGE_HEADER + field));
  62. }
  64. /*****************************************************************
  65. Sets the given header field. */
  66. UNIV_INLINE
  67. void
  68. page_header_set_field(
  69. /*==================*/
  70. page_t* page, /* in: page */
  71. ulint field, /* in: PAGE_LEVEL, ... */
  72. ulint val) /* in: value */
  73. {
  74. ut_ad(page);
  75. ut_ad(field <= PAGE_N_RECS);
  76. ut_ad(val < UNIV_PAGE_SIZE);
  78. mach_write_to_2(page + PAGE_HEADER + field, val);
  79. }
  81. /*****************************************************************
  82. Returns the pointer stored in the given header field. */
  83. UNIV_INLINE
  84. byte*
  85. page_header_get_ptr(
  86. /*================*/
  87. /* out: pointer or NULL */
  88. page_t* page, /* in: page */
  89. ulint field) /* in: PAGE_FREE, ... */
  90. {
  91. ulint offs;
  93. ut_ad(page);
  94. ut_ad((field == PAGE_FREE)
  95.       || (field == PAGE_LAST_INSERT)
  96.       || (field == PAGE_HEAP_TOP));
  98. offs = page_header_get_field(page, field);
  100. ut_ad((field != PAGE_HEAP_TOP) || offs);
  102. if (offs == 0) {
  104. return(NULL);
  105. }
  107. return(page + offs);
  108. }
  110. /*****************************************************************
  111. Sets the pointer stored in the given header field. */
  112. UNIV_INLINE
  113. void
  114. page_header_set_ptr(
  115. /*================*/
  116. page_t* page, /* in: page */
  117. ulint field, /* in: PAGE_FREE, ... */
  118. byte* ptr) /* in: pointer or NULL*/
  119. {
  120. ulint offs;
  122. ut_ad(page);
  123. ut_ad((field == PAGE_FREE)
  124.       || (field == PAGE_LAST_INSERT)
  125.       || (field == PAGE_HEAP_TOP));
  127. if (ptr == NULL) {
  128. offs = 0;
  129. } else {
  130. offs = ptr - page;
  131. }
  133. ut_ad((field != PAGE_HEAP_TOP) || offs);
  135. page_header_set_field(page, field, offs);
  136. }
  138. /*****************************************************************
  139. Resets the last insert info field in the page header. Writes to mlog
  140. about this operation. */
  141. UNIV_INLINE
  142. void
  143. page_header_reset_last_insert(
  144. /*==========================*/
  145. page_t* page, /* in: page */
  146. mtr_t* mtr) /* in: mtr */
  147. {
  148. ut_ad(page && mtr);
  150. mlog_write_ulint(page + PAGE_HEADER + PAGE_LAST_INSERT, 0,
  151. MLOG_2BYTES, mtr);
  152. }
  154. /****************************************************************
  155. Gets the first record on the page. */
  156. UNIV_INLINE
  157. rec_t*
  158. page_get_infimum_rec(
  159. /*=================*/
  160. /* out: the first record in record list */
  161. page_t* page) /* in: page which must have record(s) */
  162. {
  163. ut_ad(page);
  165. return(page + PAGE_INFIMUM);
  166. }
  168. /****************************************************************
  169. Gets the last record on the page. */
  170. UNIV_INLINE
  171. rec_t*
  172. page_get_supremum_rec(
  173. /*==================*/
  174. /* out: the last record in record list */
  175. page_t* page) /* in: page which must have record(s) */
  176. {
  177. ut_ad(page);
  179. return(page + PAGE_SUPREMUM);
  180. }
  182. /****************************************************************
  183. TRUE if the record is a user record on the page. */
  184. UNIV_INLINE
  185. ibool
  186. page_rec_is_user_rec(
  187. /*=================*/
  188. /* out: TRUE if a user record */
  189. rec_t* rec) /* in: record */
  190. {
  191. ut_ad(rec);
  193. if (rec == page_get_supremum_rec(buf_frame_align(rec))) {
  195. return(FALSE);
  196. }
  198. if (rec == page_get_infimum_rec(buf_frame_align(rec))) {
  200.       return(FALSE);
  201. }
  203. return(TRUE);
  204. }
  206. /****************************************************************
  207. TRUE if the record is the supremum record on a page. */
  208. UNIV_INLINE
  209. ibool
  210. page_rec_is_supremum(
  211. /*=================*/
  212. /* out: TRUE if the supremum record */
  213. rec_t* rec) /* in: record */
  214. {
  215. ut_ad(rec);
  217. if (rec == page_get_supremum_rec(buf_frame_align(rec))) {
  219. return(TRUE);
  220. }
  222. return(FALSE);
  223. }
  225. /****************************************************************
  226. TRUE if the record is the infimum record on a page. */
  227. UNIV_INLINE
  228. ibool
  229. page_rec_is_infimum(
  230. /*================*/
  231. /* out: TRUE if the infimum record */
  232. rec_t* rec) /* in: record */
  233. {
  234. ut_ad(rec);
  236. if (rec == page_get_infimum_rec(buf_frame_align(rec))) {
  238. return(TRUE);
  239. }
  241. return(FALSE);
  242. }
  244. /****************************************************************
  245. TRUE if the record is the first user record on the page. */
  246. UNIV_INLINE
  247. ibool
  248. page_rec_is_first_user_rec(
  249. /*=======================*/
  250. /* out: TRUE if first user record */
  251. rec_t* rec) /* in: record */
  252. {
  253. ut_ad(rec);
  255. if (rec == page_get_supremum_rec(buf_frame_align(rec))) {
  257. return(FALSE);
  258. }
  260. if (rec == page_rec_get_next(
  261.       page_get_infimum_rec(buf_frame_align(rec)))) {
  263.       return(TRUE);
  264. }
  266. return(FALSE);
  267. }
  269. /****************************************************************
  270. TRUE if the record is the last user record on the page. */
  271. UNIV_INLINE
  272. ibool
  273. page_rec_is_last_user_rec(
  274. /*======================*/
  275. /* out: TRUE if last user record */
  276. rec_t* rec) /* in: record */
  277. {
  278. ut_ad(rec);
  280. if (rec == page_get_supremum_rec(buf_frame_align(rec))) {
  282. return(FALSE);
  283. }
  285. if (page_rec_get_next(rec)
  286. == page_get_supremum_rec(buf_frame_align(rec))) {
  288.       return(TRUE);
  289. }
  291. return(FALSE);
  292. }
  294. /*****************************************************************
  295. Compares a data tuple to a physical record. Differs from the function
  296. cmp_dtuple_rec_with_match in the way that the record must reside on an
  297. index page, and also page infimum and supremum records can be given in
  298. the parameter rec. These are considered as the negative infinity and
  299. the positive infinity in the alphabetical order. */
  300. UNIV_INLINE
  301. int
  302. page_cmp_dtuple_rec_with_match(
  303. /*===========================*/
  304. /* out: 1, 0, -1, if dtuple is greater, equal, 
  305. less than rec, respectively, when only the 
  306. common first fields are compared */
  307. dtuple_t* dtuple, /* in: data tuple */
  308. rec_t* rec, /* in: physical record on a page; may also 
  309. be page infimum or supremum, in which case 
  310. matched-parameter values below are not 
  311. affected */
  312. ulint*   matched_fields, /* in/out: number of already completely 
  313. matched fields; when function returns
  314. contains the value for current comparison */
  315. ulint*    matched_bytes) /* in/out: number of already matched 
  316. bytes within the first field not completely
  317. matched; when function returns contains the
  318. value for current comparison */
  319. {
  320. page_t* page;
  322. ut_ad(dtuple_check_typed(dtuple));
  324. page = buf_frame_align(rec);
  326. if (rec == page_get_infimum_rec(page)) {
  327. return(1);
  328. } else if (rec == page_get_supremum_rec(page)) {
  329. return(-1);
  330. } else {
  331. return(cmp_dtuple_rec_with_match(dtuple, rec,
  332. matched_fields,
  333. matched_bytes));
  334. }
  335. }
  337. /*****************************************************************
  338. Gets the number of user records on page (infimum and supremum records
  339. are not user records). */
  340. UNIV_INLINE
  341. ulint
  342. page_get_n_recs(
  343. /*============*/
  344. /* out: number of user records */
  345. page_t* page) /* in: index page */
  346. {
  347. return(page_header_get_field(page, PAGE_N_RECS));
  348. }
  350. /*****************************************************************
  351. Gets the number of dir slots in directory. */
  352. UNIV_INLINE
  353. ulint
  354. page_dir_get_n_slots(
  355. /*=================*/
  356. /* out: number of slots */
  357. page_t* page) /* in: index page */
  358. {
  359. return(page_header_get_field(page, PAGE_N_DIR_SLOTS));
  360. }
  362. /*****************************************************************
  363. Gets pointer to nth directory slot. */
  364. UNIV_INLINE
  365. page_dir_slot_t*
  366. page_dir_get_nth_slot(
  367. /*==================*/
  368. /* out: pointer to dir slot */
  369. page_t* page, /* in: index page */
  370. ulint n) /* in: position */
  371. {
  372. ut_ad(page_header_get_field(page, PAGE_N_DIR_SLOTS) > n);
  374. return(page + UNIV_PAGE_SIZE - PAGE_DIR
  375. - (n + 1) * PAGE_DIR_SLOT_SIZE);
  376. }
  378. /******************************************************************
  379. Used to check the consistency of a record on a page. */
  380. UNIV_INLINE
  381. ibool
  382. page_rec_check(
  383. /*===========*/
  384. /* out: TRUE if succeed */
  385. rec_t* rec) /* in: record */
  386. {
  387. page_t* page;
  389. ut_a(rec);
  391. page = buf_frame_align(rec);
  393. ut_a(rec <= page_header_get_ptr(page, PAGE_HEAP_TOP));
  394. ut_a(rec >= page + PAGE_DATA);
  396. return(TRUE);
  397. }
  399. /******************************************************************
  400. Used to check the consistency of a directory slot. */
  401. UNIV_INLINE
  402. ibool
  403. page_dir_slot_check(
  404. /*================*/
  405. /* out: TRUE if succeed */
  406. page_dir_slot_t* slot) /* in: slot */
  407. {
  408. page_t* page;
  409. ulint n_slots;
  410. ulint n_owned;
  412. ut_a(slot);
  414. page = buf_frame_align(slot);
  416. n_slots = page_header_get_field(page, PAGE_N_DIR_SLOTS);
  418. ut_a(slot <= page_dir_get_nth_slot(page, 0));
  419. ut_a(slot >= page_dir_get_nth_slot(page, n_slots - 1));
  421. ut_a(page_rec_check(page + mach_read_from_2(slot)));
  423. n_owned = rec_get_n_owned(page + mach_read_from_2(slot));
  425. if (slot == page_dir_get_nth_slot(page, 0)) {
  426. ut_a(n_owned == 1);
  427. } else if (slot == page_dir_get_nth_slot(page, n_slots - 1)) {
  428. ut_a(n_owned >= 1);
  429. ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
  430. } else {
  431. ut_a(n_owned >= PAGE_DIR_SLOT_MIN_N_OWNED);
  432. ut_a(n_owned <= PAGE_DIR_SLOT_MAX_N_OWNED);
  433. }
  435. return(TRUE);
  436. }
  438. /*******************************************************************
  439. Gets the record pointed to by a directory slot. */
  440. UNIV_INLINE
  441. rec_t*
  442. page_dir_slot_get_rec(
  443. /*==================*/
  444. /* out: pointer to record */
  445. page_dir_slot_t* slot) /* in: directory slot */
  446. {
  447. return(buf_frame_align(slot) + mach_read_from_2(slot));
  448. }
  450. /*******************************************************************
  451. This is used to set the record offset in a directory slot. */
  452. UNIV_INLINE
  453. void
  454. page_dir_slot_set_rec(
  455. /*==================*/
  456. page_dir_slot_t* slot, /* in: directory slot */
  457. rec_t*  rec) /* in: record on the page */
  458. {
  459. ut_ad(page_rec_check(rec));
  461. mach_write_to_2(slot, rec - buf_frame_align(rec));
  462. }
  464. /*******************************************************************
  465. Gets the number of records owned by a directory slot. */
  466. UNIV_INLINE
  467. ulint
  468. page_dir_slot_get_n_owned(
  469. /*======================*/
  470. /* out: number of records */
  471. page_dir_slot_t*  slot) /* in: page directory slot */
  472. {
  473. return(rec_get_n_owned(page_dir_slot_get_rec(slot)));
  474. }
  476. /*******************************************************************
  477. This is used to set the owned records field of a directory slot. */
  478. UNIV_INLINE
  479. void
  480. page_dir_slot_set_n_owned(
  481. /*======================*/
  482. page_dir_slot_t* slot, /* in: directory slot */
  483. ulint n) /* in: number of records owned 
  484. by the slot */
  485. {
  486. rec_set_n_owned(page_dir_slot_get_rec(slot), n);
  487. }
  489. /****************************************************************
  490. Calculates the space reserved for directory slots of a given number of
  491. records. The exact value is a fraction number n * PAGE_DIR_SLOT_SIZE /
  492. PAGE_DIR_SLOT_MIN_N_OWNED, and it is rounded upwards to an integer. */
  493. UNIV_INLINE
  494. ulint
  495. page_dir_calc_reserved_space(
  496. /*=========================*/
  497. ulint n_recs) /* in: number of records */
  498. {
  499. return((PAGE_DIR_SLOT_SIZE * n_recs + PAGE_DIR_SLOT_MIN_N_OWNED - 1)
  500. / PAGE_DIR_SLOT_MIN_N_OWNED);
  501. } 
  503. /****************************************************************
  504. Gets the pointer to the next record on the page. */
  505. UNIV_INLINE
  506. rec_t*
  507. page_rec_get_next(
  508. /*==============*/
  509. /* out: pointer to next record */
  510. rec_t* rec) /* in: pointer to record */
  511. {
  512. ulint offs;
  513. page_t* page;
  515. ut_ad(page_rec_check(rec));
  517. page = buf_frame_align(rec);
  519. offs = rec_get_next_offs(rec);
  521. if (offs == 0) {
  523. return(NULL);
  524. }
  526. return(page + offs);
  527. }
  529. /*******************************************************************
  530. Looks for the directory slot which owns the given record. */
  531. UNIV_INLINE
  532. ulint
  533. page_dir_find_owner_slot(
  534. /*=====================*/
  535. /* out: the directory slot number */
  536. rec_t* rec) /* in: the physical record */
  537. {
  538. ulint i;
  539. page_t* page;
  540. page_dir_slot_t* slot;
  542. ut_ad(page_rec_check(rec));
  544. while (rec_get_n_owned(rec) == 0) {
  545. rec = page_rec_get_next(rec);
  546. }
  548. page = buf_frame_align(rec);
  550. i = page_dir_get_n_slots(page) - 1;
  551. slot = page_dir_get_nth_slot(page, i); 
  553. while (page_dir_slot_get_rec(slot) != rec) {
  554. i--;
  555. slot = page_dir_get_nth_slot(page, i); 
  556. }
  558. return(i);
  559. }
  561. /****************************************************************
  562. Sets the pointer to the next record on the page. */ 
  563. UNIV_INLINE
  564. void
  565. page_rec_set_next(
  566. /*==============*/
  567. rec_t* rec, /* in: pointer to record, must not be page supremum */
  568. rec_t* next) /* in: pointer to next record, must not be page
  569. infimum */
  570. {
  571. page_t* page;
  573. ut_ad(page_rec_check(rec));
  574. ut_ad((next == NULL)
  575.       || (buf_frame_align(rec) == buf_frame_align(next)));
  577. page = buf_frame_align(rec);
  579. ut_ad(rec != page_get_supremum_rec(page));
  580. ut_ad(next != page_get_infimum_rec(page));
  582. if (next == NULL) {
  583. rec_set_next_offs(rec, 0);
  584. } else {
  585. rec_set_next_offs(rec, (ulint)(next - page));
  586. }
  587. }
  589. /****************************************************************
  590. Gets the pointer to the previous record. */
  591. UNIV_INLINE
  592. rec_t*
  593. page_rec_get_prev(
  594. /*==============*/
  595. /* out: pointer to previous record */
  596. rec_t* rec) /* in: pointer to record, must not be page
  597. infimum */
  598. {
  599. page_dir_slot_t* slot;
  600. ulint slot_no;
  601. rec_t* rec2;
  602. rec_t* prev_rec = NULL;
  603. page_t* page;
  605. ut_ad(page_rec_check(rec));
  607. page = buf_frame_align(rec);
  609. ut_ad(rec != page_get_infimum_rec(page));
  611. slot_no = page_dir_find_owner_slot(rec);
  613. ut_ad(slot_no != 0);
  615. slot = page_dir_get_nth_slot(page, slot_no - 1);
  617. rec2 = page_dir_slot_get_rec(slot);
  619. while (rec != rec2) {
  620. prev_rec = rec2;
  621. rec2 = page_rec_get_next(rec2);
  622. }
  624. ut_ad(prev_rec);
  626. return(prev_rec);
  627. }
  629. /*******************************************************************
  630. Looks for the record which owns the given record. */
  631. UNIV_INLINE
  632. rec_t*
  633. page_rec_find_owner_rec(
  634. /*====================*/
  635. /* out: the owner record */
  636. rec_t* rec) /* in: the physical record */
  637. {
  638. ut_ad(page_rec_check(rec));
  640. while (rec_get_n_owned(rec) == 0) {
  641. rec = page_rec_get_next(rec);
  642. }
  644. return(rec);
  645. }
  647. /****************************************************************
  648. Returns the sum of the sizes of the records in the record list, excluding
  649. the infimum and supremum records. */
  650. UNIV_INLINE
  651. ulint
  652. page_get_data_size(
  653. /*===============*/
  654. /* out: data in bytes */
  655. page_t* page) /* in: index page */
  656. {
  657. ulint ret;
  659. ret = (ulint)(page_header_get_field(page, PAGE_HEAP_TOP)
  660.       - PAGE_SUPREMUM_END
  661.       - page_header_get_field(page, PAGE_GARBAGE));
  663. ut_ad(ret < UNIV_PAGE_SIZE);
  665. return(ret);
  666. }
  668. /*****************************************************************
  669. Calculates free space if a page is emptied. */
  670. UNIV_INLINE
  671. ulint
  672. page_get_free_space_of_empty(void)
  673. /*==============================*/
  674. /* out: free space */
  675. {
  676. return((ulint)(UNIV_PAGE_SIZE
  677. - PAGE_SUPREMUM_END
  678. - PAGE_DIR
  679. - 2 * PAGE_DIR_SLOT_SIZE));
  680. }
  682. /****************************************************************
  683. Each user record on a page, and also the deleted user records in the heap
  684. takes its size plus the fraction of the dir cell size /
  685. PAGE_DIR_SLOT_MIN_N_OWNED bytes for it. If the sum of these exceeds the
  686. value of page_get_free_space_of_empty, the insert is impossible, otherwise
  687. it is allowed. This function returns the maximum combined size of records
  688. which can be inserted on top of the record heap. */
  689. UNIV_INLINE
  690. ulint
  691. page_get_max_insert_size(
  692. /*=====================*/
  693. /* out: maximum combined size for inserted records */
  694. page_t* page, /* in: index page */
  695. ulint n_recs) /* in: number of records */
  696. {
  697. ulint occupied;
  698. ulint free_space;
  700. occupied = page_header_get_field(page, PAGE_HEAP_TOP)
  701. - PAGE_SUPREMUM_END
  702. + page_dir_calc_reserved_space(
  703.      n_recs + (page_header_get_field(page, PAGE_N_HEAP) - 2));
  705. free_space = page_get_free_space_of_empty();
  706.      
  707. /* Above the 'n_recs +' part reserves directory space for the new
  708. inserted records; the '- 2' excludes page infimum and supremum
  709. records */
  711. if (occupied > free_space) {
  713. return(0);
  714. }
  716. return(free_space - occupied);
  717. }
  719. /****************************************************************
  720. Returns the maximum combined size of records which can be inserted on top
  721. of the record heap if a page is first reorganized. */
  722. UNIV_INLINE
  723. ulint
  724. page_get_max_insert_size_after_reorganize(
  725. /*======================================*/
  726. /* out: maximum combined size for inserted records */
  727. page_t* page, /* in: index page */
  728. ulint n_recs) /* in: number of records */
  729. {
  730. ulint occupied;
  731. ulint free_space;
  733. occupied = page_get_data_size(page)
  734. + page_dir_calc_reserved_space(n_recs + page_get_n_recs(page));
  736. free_space = page_get_free_space_of_empty();
  738. if (occupied > free_space) {
  740. return(0);
  741. }
  743. return(free_space - occupied);
  744. }
  746. /****************************************************************
  747. Puts a record to free list. */
  748. UNIV_INLINE
  749. void
  750. page_mem_free(
  751. /*==========*/
  752. page_t* page, /* in: index page */
  753. rec_t* rec) /* in: pointer to the (origin of) record */
  754. {
  755. rec_t* free;
  756. ulint garbage;
  758. free = page_header_get_ptr(page, PAGE_FREE);
  760. page_rec_set_next(rec, free);
  761. page_header_set_ptr(page, PAGE_FREE, rec);
  763. garbage = page_header_get_field(page, PAGE_GARBAGE);
  765. page_header_set_field(page, PAGE_GARBAGE,
  766. garbage + rec_get_size(rec));
  767. }
  769. #ifdef UNIV_MATERIALIZE
  770. #undef UNIV_INLINE
  771. #define UNIV_INLINE UNIV_INLINE_ORIGINAL
  772. #endif