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

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. Record manager
  3. (c) 1994-1996 Innobase Oy
  4. Created 5/30/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #include "mach0data.h"
  7. #include "ut0byte.h"
  8. /* Offsets of the bit-fields in the record. NOTE! In the table the most 
  9. significant bytes and bits are written below less significant.
  10. (1) byte offset (2) bit usage within byte
  11. downward from
  12. origin -> 1 8 bits pointer to next record
  13. 2 8 bits pointer to next record
  14. 3   1 bit short flag
  15. 7 bits number of fields
  16. 4 3 bits number of fields
  17. 5 bits heap number
  18. 5 8 bits heap number
  19. 6 4 bits n_owned
  20. 4 bits info bits
  21. */
  22. /* We list the byte offsets from the origin of the record, the mask,
  23. and the shift needed to obtain each bit-field of the record. */
  24. #define REC_NEXT 2
  25. #define REC_NEXT_MASK 0xFFFFUL
  26. #define REC_NEXT_SHIFT 0
  27. #define REC_SHORT 3 /* This is single byte bit-field */
  28. #define REC_SHORT_MASK 0x1UL
  29. #define REC_SHORT_SHIFT 0
  30. #define REC_N_FIELDS 4
  31. #define REC_N_FIELDS_MASK 0x7FEUL
  32. #define REC_N_FIELDS_SHIFT 1
  33. #define REC_HEAP_NO 5
  34. #define REC_HEAP_NO_MASK 0xFFF8UL
  35. #define REC_HEAP_NO_SHIFT 3
  36. #define REC_N_OWNED 6 /* This is single byte bit-field */
  37. #define REC_N_OWNED_MASK 0xFUL
  38. #define REC_N_OWNED_SHIFT 0
  39. #define REC_INFO_BITS_MASK 0xF0UL
  40. #define REC_INFO_BITS_SHIFT 0
  41. /* The deleted flag in info bits */
  42. #define REC_INFO_DELETED_FLAG  0x20UL /* when bit is set to 1, it means the
  43. record has been delete marked */
  44. /* The following masks are used to filter the SQL null bit from
  45. one-byte and two-byte offsets */
  46. #define REC_1BYTE_SQL_NULL_MASK 0x80UL
  47. #define REC_2BYTE_SQL_NULL_MASK 0x8000UL
  48. /* In a 2-byte offset the second most significant bit denotes
  49. a field stored to another page: */
  50. #define REC_2BYTE_EXTERN_MASK 0x4000UL
  51. /****************************************************************
  52. Return field length or UNIV_SQL_NULL. */
  53. UNIV_INLINE
  54. ulint
  55. rec_get_nth_field_len(
  56. /*==================*/
  57.   /* out: length of the field; UNIV_SQL_NULL if SQL
  58. null */
  59.   rec_t* rec,  /* in: record */
  60.   ulint n) /* in: index of the field */
  61. {
  62. ulint len;
  63. rec_get_nth_field(rec, n, &len);
  64. return(len);
  65. }
  66. /***************************************************************
  67. Sets the value of the ith field SQL null bit. */
  68. void
  69. rec_set_nth_field_null_bit(
  70. /*=======================*/
  71. rec_t* rec, /* in: record */
  72. ulint i, /* in: ith field */
  73. ibool val); /* in: value to set */
  74. /*************************************************************** 
  75. Sets a record field to SQL null. The physical size of the field is not
  76. changed. */
  77. void
  78. rec_set_nth_field_sql_null(
  79. /*=======================*/
  80. rec_t* rec,  /* in: record */
  81. ulint n); /* in: index of the field */
  82. /**********************************************************
  83. Gets a bit field from within 1 byte. */
  84. UNIV_INLINE
  85. ulint
  86. rec_get_bit_field_1(
  87. /*================*/
  88. rec_t* rec, /* in: pointer to record origin */
  89. ulint offs, /* in: offset from the origin down */
  90. ulint mask, /* in: mask used to filter bits */
  91. ulint shift) /* in: shift right applied after masking */
  92. {
  93. ut_ad(rec);
  94. return((mach_read_from_1(rec - offs) & mask) >> shift);
  95. }
  96. /**********************************************************
  97. Sets a bit field within 1 byte. */
  98. UNIV_INLINE
  99. void
  100. rec_set_bit_field_1(
  101. /*================*/
  102. rec_t* rec, /* in: pointer to record origin */
  103. ulint val, /* in: value to set */
  104. ulint offs, /* in: offset from the origin down */
  105. ulint mask, /* in: mask used to filter bits */
  106. ulint shift) /* in: shift right applied after masking */
  107. {
  108. ut_ad(rec);
  109. ut_ad(offs <= REC_N_EXTRA_BYTES);
  110. ut_ad(mask);
  111. ut_ad(mask <= 0xFFUL);
  112. ut_ad(((mask >> shift) << shift) == mask);
  113. ut_ad(((val << shift) & mask) == (val << shift));
  114. mach_write_to_1(rec - offs, 
  115. (mach_read_from_1(rec - offs) & ~mask) 
  116. | (val << shift));
  117. }
  118. /**********************************************************
  119. Gets a bit field from within 2 bytes. */
  120. UNIV_INLINE
  121. ulint
  122. rec_get_bit_field_2(
  123. /*================*/
  124. rec_t* rec, /* in: pointer to record origin */
  125. ulint offs, /* in: offset from the origin down */
  126. ulint mask, /* in: mask used to filter bits */
  127. ulint shift) /* in: shift right applied after masking */
  128. {
  129. ut_ad(rec);
  130. return((mach_read_from_2(rec - offs) & mask) >> shift);
  131. }
  132. /**********************************************************
  133. Sets a bit field within 2 bytes. */
  134. UNIV_INLINE
  135. void
  136. rec_set_bit_field_2(
  137. /*================*/
  138. rec_t* rec, /* in: pointer to record origin */
  139. ulint val, /* in: value to set */
  140. ulint offs, /* in: offset from the origin down */
  141. ulint mask, /* in: mask used to filter bits */
  142. ulint shift) /* in: shift right applied after masking */
  143. {
  144. ut_ad(rec);
  145. ut_ad(offs <= REC_N_EXTRA_BYTES);
  146. ut_ad(mask > 0xFFUL);
  147. ut_ad(mask <= 0xFFFFUL);
  148. ut_ad((mask >> shift) & 1);
  149. ut_ad(0 == ((mask >> shift) & ((mask >> shift) + 1)));
  150. ut_ad(((mask >> shift) << shift) == mask);
  151. ut_ad(((val << shift) & mask) == (val << shift));
  152. #ifdef UNIV_DEBUG
  153.       {
  154. ulint m;
  155. /* The following assertion checks that the masks of currently
  156. defined bit-fields in bytes 3-6 do not overlap. */
  157. m = (ulint)((REC_SHORT_MASK << (8 * (REC_SHORT - 3)))
  158.    + (REC_N_FIELDS_MASK << (8 * (REC_N_FIELDS - 4)))
  159.    + (REC_HEAP_NO_MASK << (8 * (REC_HEAP_NO - 4)))
  160.    + (REC_N_OWNED_MASK << (8 * (REC_N_OWNED - 3)))
  161.   + (REC_INFO_BITS_MASK << (8 * (REC_INFO_BITS - 3))));
  162. if (m != ut_dbg_zero + 0xFFFFFFFFUL) {
  163. fprintf(stderr, "Sum of masks %lxn", m);
  164. ut_error;
  165. }
  166.       }
  167. #endif
  168. mach_write_to_2(rec - offs, 
  169. (mach_read_from_2(rec - offs) & ~mask) 
  170. | (val << shift));
  171. }
  172. /**********************************************************
  173. The following function is used to get the offset of the next chained record
  174. on the same page. */
  175. UNIV_INLINE
  176. ulint 
  177. rec_get_next_offs(
  178. /*==============*/
  179. /* out: the page offset of the next chained record */
  180. rec_t* rec) /* in: physical record */
  181. {
  182. ulint ret;
  183. ut_ad(rec);
  184. ret = rec_get_bit_field_2(rec, REC_NEXT, REC_NEXT_MASK,
  185. REC_NEXT_SHIFT);
  186. ut_ad(ret < UNIV_PAGE_SIZE);
  187. return(ret);
  188. }
  189. /**********************************************************
  190. The following function is used to set the next record offset field of the
  191. record. */
  192. UNIV_INLINE
  193. void
  194. rec_set_next_offs(
  195. /*==============*/
  196. rec_t* rec, /* in: physical record */
  197. ulint next) /* in: offset of the next record */
  198. {
  199. ut_ad(rec);
  200. ut_ad(UNIV_PAGE_SIZE > next);
  201. rec_set_bit_field_2(rec, next, REC_NEXT, REC_NEXT_MASK,
  202. REC_NEXT_SHIFT);
  203. }
  204. /**********************************************************
  205. The following function is used to get the number of fields in the record. */
  206. UNIV_INLINE
  207. ulint
  208. rec_get_n_fields(
  209. /*=============*/
  210. /* out: number of data fields */
  211. rec_t* rec) /* in: physical record */
  212. {
  213. ulint ret;
  214. ut_ad(rec);
  215. ret = rec_get_bit_field_2(rec, REC_N_FIELDS, REC_N_FIELDS_MASK,
  216. REC_N_FIELDS_SHIFT);
  217. ut_ad(ret <= REC_MAX_N_FIELDS);
  218. ut_ad(ret > 0);
  219. return(ret);
  220. }
  221. /**********************************************************
  222. The following function is used to set the number of fields field in the
  223. record. */
  224. UNIV_INLINE
  225. void
  226. rec_set_n_fields(
  227. /*=============*/
  228. rec_t* rec, /* in: physical record */
  229. ulint n_fields) /* in: the number of fields */
  230. {
  231. ut_ad(rec);
  232. ut_ad(n_fields <= REC_MAX_N_FIELDS);
  233. ut_ad(n_fields > 0);
  234. rec_set_bit_field_2(rec, n_fields, REC_N_FIELDS, REC_N_FIELDS_MASK,
  235. REC_N_FIELDS_SHIFT);
  236. }
  237. /**********************************************************
  238. The following function is used to get the number of records owned by the
  239. previous directory record. */
  240. UNIV_INLINE
  241. ulint
  242. rec_get_n_owned(
  243. /*============*/
  244. /* out: number of owned records */
  245. rec_t* rec) /* in: physical record */
  246. {
  247. ulint ret;
  248. ut_ad(rec);
  249. ret = rec_get_bit_field_1(rec, REC_N_OWNED, REC_N_OWNED_MASK,
  250. REC_N_OWNED_SHIFT);
  251. ut_ad(ret <= REC_MAX_N_OWNED); 
  252. return(ret);
  253. }
  254. /**********************************************************
  255. The following function is used to set the number of owned records. */
  256. UNIV_INLINE
  257. void
  258. rec_set_n_owned(
  259. /*============*/
  260. rec_t* rec, /* in: physical record */
  261. ulint n_owned) /* in: the number of owned */
  262. {
  263. ut_ad(rec);
  264. ut_ad(n_owned <= REC_MAX_N_OWNED);
  265. rec_set_bit_field_1(rec, n_owned, REC_N_OWNED, REC_N_OWNED_MASK,
  266. REC_N_OWNED_SHIFT);
  267. }
  268. /**********************************************************
  269. The following function is used to retrieve the info bits of a record. */
  270. UNIV_INLINE
  271. ulint
  272. rec_get_info_bits(
  273. /*==============*/
  274. /* out: info bits */
  275. rec_t* rec) /* in: physical record */
  276. {
  277. ulint ret;
  278. ut_ad(rec);
  279. ret = rec_get_bit_field_1(rec, REC_INFO_BITS, REC_INFO_BITS_MASK,
  280. REC_INFO_BITS_SHIFT);
  281. ut_ad((ret & ~REC_INFO_BITS_MASK) == 0);
  282. return(ret);
  283. }
  284. /**********************************************************
  285. The following function is used to set the info bits of a record. */
  286. UNIV_INLINE
  287. void
  288. rec_set_info_bits(
  289. /*==============*/
  290. rec_t* rec, /* in: physical record */
  291. ulint bits) /* in: info bits */
  292. {
  293. ut_ad(rec);
  294. ut_ad((bits & ~REC_INFO_BITS_MASK) == 0);
  295. rec_set_bit_field_1(rec, bits, REC_INFO_BITS, REC_INFO_BITS_MASK,
  296. REC_INFO_BITS_SHIFT);
  297. }
  298. /**********************************************************
  299. Gets the value of the deleted flag in info bits. */
  300. UNIV_INLINE
  301. ibool
  302. rec_info_bits_get_deleted_flag(
  303. /*===========================*/
  304. /* out: TRUE if deleted flag set */
  305. ulint info_bits) /* in: info bits from a record */
  306. {
  307. if (info_bits & REC_INFO_DELETED_FLAG) {
  308. return(TRUE);
  309. }
  310. return(FALSE);
  311. }
  312. /**********************************************************
  313. The following function tells if record is delete marked. */
  314. UNIV_INLINE
  315. ibool
  316. rec_get_deleted_flag(
  317. /*=================*/
  318. /* out: TRUE if delete marked */
  319. rec_t* rec) /* in: physical record */
  320. {
  321. if (REC_INFO_DELETED_FLAG & rec_get_info_bits(rec)) {
  322. return(TRUE);
  323. }
  324. return(FALSE);
  325. }
  326. /**********************************************************
  327. The following function is used to set the deleted bit. */
  328. UNIV_INLINE
  329. void
  330. rec_set_deleted_flag(
  331. /*=================*/
  332. rec_t* rec, /* in: physical record */
  333. ibool flag) /* in: TRUE if delete marked */
  334. {
  335. ulint old_val;
  336. ulint new_val;
  337. ut_ad(TRUE == 1);
  338. ut_ad(flag <= TRUE);
  339. old_val = rec_get_info_bits(rec);
  340. if (flag) {
  341. new_val = REC_INFO_DELETED_FLAG | old_val;
  342. } else {
  343. new_val = ~REC_INFO_DELETED_FLAG & old_val;
  344. }
  345. rec_set_info_bits(rec, new_val);
  346. }
  347. /**********************************************************
  348. The following function is used to get the order number of the record in the
  349. heap of the index page. */
  350. UNIV_INLINE
  351. ulint
  352. rec_get_heap_no(
  353. /*=============*/
  354. /* out: heap order number */
  355. rec_t* rec) /* in: physical record */
  356. {
  357. ulint ret;
  358. ut_ad(rec);
  359. ret = rec_get_bit_field_2(rec, REC_HEAP_NO, REC_HEAP_NO_MASK,
  360. REC_HEAP_NO_SHIFT);
  361. ut_ad(ret <= REC_MAX_HEAP_NO);
  362. return(ret);
  363. }
  364. /**********************************************************
  365. The following function is used to set the heap number field in the record. */
  366. UNIV_INLINE
  367. void
  368. rec_set_heap_no(
  369. /*=============*/
  370. rec_t* rec, /* in: physical record */
  371. ulint heap_no)/* in: the heap number */
  372. {
  373. ut_ad(heap_no <= REC_MAX_HEAP_NO);
  374. rec_set_bit_field_2(rec, heap_no, REC_HEAP_NO, REC_HEAP_NO_MASK,
  375. REC_HEAP_NO_SHIFT);
  376. }
  377. /**********************************************************
  378. The following function is used to test whether the data offsets in the record
  379. are stored in one-byte or two-byte format. */
  380. UNIV_INLINE
  381. ibool
  382. rec_get_1byte_offs_flag(
  383. /*====================*/
  384. /* out: TRUE if 1-byte form */
  385. rec_t* rec) /* in: physical record */
  386. {
  387. ut_ad(TRUE == 1);
  388. return(rec_get_bit_field_1(rec, REC_SHORT, REC_SHORT_MASK,
  389. REC_SHORT_SHIFT));
  390. }
  391. /**********************************************************
  392. The following function is used to set the 1-byte offsets flag. */
  393. UNIV_INLINE
  394. void
  395. rec_set_1byte_offs_flag(
  396. /*====================*/
  397. rec_t* rec, /* in: physical record */
  398. ibool flag) /* in: TRUE if 1byte form */
  399. {
  400. ut_ad(TRUE == 1);
  401. ut_ad(flag <= TRUE);
  402. rec_set_bit_field_1(rec, flag, REC_SHORT, REC_SHORT_MASK,
  403. REC_SHORT_SHIFT);
  404. }
  405. /**********************************************************
  406. Returns the offset of nth field end if the record is stored in the 1-byte
  407. offsets form. If the field is SQL null, the flag is ORed in the returned
  408. value. */
  409. UNIV_INLINE
  410. ulint
  411. rec_1_get_field_end_info(
  412. /*=====================*/
  413.   /* out: offset of the start of the field, SQL null
  414.   flag ORed */
  415.   rec_t* rec,  /* in: record */
  416.   ulint n) /* in: field index */
  417. {
  418. ut_ad(rec_get_1byte_offs_flag(rec));
  419. ut_ad(n < rec_get_n_fields(rec));
  420. return(mach_read_from_1(rec - (REC_N_EXTRA_BYTES + n + 1)));
  421. }
  422. /**********************************************************
  423. Returns the offset of nth field end if the record is stored in the 2-byte
  424. offsets form. If the field is SQL null, the flag is ORed in the returned
  425. value. */
  426. UNIV_INLINE
  427. ulint
  428. rec_2_get_field_end_info(
  429. /*=====================*/
  430.   /* out: offset of the start of the field, SQL null
  431.   flag and extern storage flag ORed */
  432.   rec_t* rec,  /* in: record */
  433.   ulint n) /* in: field index */
  434. {
  435. ut_ad(!rec_get_1byte_offs_flag(rec));
  436. ut_ad(n < rec_get_n_fields(rec));
  437. return(mach_read_from_2(rec - (REC_N_EXTRA_BYTES + 2 * n + 2)));
  438. }
  439. /***************************************************************
  440. Gets the value of the ith field extern storage bit. If it is TRUE
  441. it means that the field is stored on another page. */
  442. UNIV_INLINE
  443. ibool
  444. rec_get_nth_field_extern_bit(
  445. /*=========================*/
  446. /* in: TRUE or FALSE */
  447. rec_t* rec, /* in: record */
  448. ulint i) /* in: ith field */
  449. {
  450. ulint info;
  451. if (rec_get_1byte_offs_flag(rec)) {
  452. return(FALSE);
  453. }
  454. info = rec_2_get_field_end_info(rec, i);
  455. if (info & REC_2BYTE_EXTERN_MASK) {
  456. return(TRUE);
  457. }
  458. return(FALSE);
  459. }
  460. /**********************************************************
  461. Returns TRUE if the extern bit is set in any of the fields
  462. of rec. */
  463. UNIV_INLINE
  464. ibool
  465. rec_contains_externally_stored_field(
  466. /*=================================*/
  467. /* out: TRUE if a field is stored externally */
  468. rec_t* rec) /* in: record */
  469. {
  470. ulint n;
  471. ulint i;
  472. if (rec_get_1byte_offs_flag(rec)) {
  473. return(FALSE);
  474. }
  475. n = rec_get_n_fields(rec);
  476. for (i = 0; i < n; i++) {
  477. if (rec_get_nth_field_extern_bit(rec, i)) {
  478. return(TRUE);
  479. }
  480. }
  481. return(FALSE);
  482. }
  483. /**********************************************************
  484. Returns the offset of n - 1th field end if the record is stored in the 1-byte
  485. offsets form. If the field is SQL null, the flag is ORed in the returned
  486. value. This function and the 2-byte counterpart are defined here because the
  487. C-compilerwas not able to sum negative and positive constant offsets, and
  488. warned of constant arithmetic overflow within the compiler. */
  489. UNIV_INLINE
  490. ulint
  491. rec_1_get_prev_field_end_info(
  492. /*==========================*/
  493.   /* out: offset of the start of the PREVIOUS field, SQL
  494. null flag ORed */
  495.   rec_t* rec,  /* in: record */
  496.   ulint n) /* in: field index */
  497. {
  498. ut_ad(rec_get_1byte_offs_flag(rec));
  499. ut_ad(n <= rec_get_n_fields(rec));
  500. return(mach_read_from_1(rec - (REC_N_EXTRA_BYTES + n)));
  501. }
  502. /**********************************************************
  503. Returns the offset of n - 1th field end if the record is stored in the 2-byte
  504. offsets form. If the field is SQL null, the flag is ORed in the returned
  505. value. */
  506. UNIV_INLINE
  507. ulint
  508. rec_2_get_prev_field_end_info(
  509. /*==========================*/
  510.   /* out: offset of the start of the PREVIOUS field, SQL
  511. null flag ORed */
  512.   rec_t* rec,  /* in: record */
  513.   ulint n) /* in: field index */
  514. {
  515. ut_ad(!rec_get_1byte_offs_flag(rec));
  516. ut_ad(n <= rec_get_n_fields(rec));
  517. return(mach_read_from_2(rec - (REC_N_EXTRA_BYTES + 2 * n)));
  518. }
  519. /**********************************************************
  520. Sets the field end info for the nth field if the record is stored in the
  521. 1-byte format. */
  522. UNIV_INLINE
  523. void
  524. rec_1_set_field_end_info(
  525. /*=====================*/
  526.   rec_t* rec,  /* in: record */
  527.   ulint n, /* in: field index */
  528.   ulint info) /* in: value to set */
  529. {
  530. ut_ad(rec_get_1byte_offs_flag(rec));
  531. ut_ad(n < rec_get_n_fields(rec));
  532. mach_write_to_1(rec - (REC_N_EXTRA_BYTES + n + 1), info);
  533. }
  534. /**********************************************************
  535. Sets the field end info for the nth field if the record is stored in the
  536. 2-byte format. */
  537. UNIV_INLINE
  538. void
  539. rec_2_set_field_end_info(
  540. /*=====================*/
  541.   rec_t* rec,  /* in: record */
  542.   ulint n, /* in: field index */
  543.   ulint info) /* in: value to set */
  544. {
  545. ut_ad(!rec_get_1byte_offs_flag(rec));
  546. ut_ad(n < rec_get_n_fields(rec));
  547. mach_write_to_2(rec - (REC_N_EXTRA_BYTES + 2 * n + 2), info);
  548. }
  549. /**********************************************************
  550. Returns the offset of nth field start if the record is stored in the 1-byte
  551. offsets form. */
  552. UNIV_INLINE
  553. ulint
  554. rec_1_get_field_start_offs(
  555. /*=======================*/
  556.   /* out: offset of the start of the field */
  557.   rec_t* rec,  /* in: record */
  558.   ulint n) /* in: field index */
  559. {
  560. ut_ad(rec_get_1byte_offs_flag(rec));
  561. ut_ad(n <= rec_get_n_fields(rec));
  562. if (n == 0) {
  563. return(0);
  564. }
  565. return(rec_1_get_prev_field_end_info(rec, n)
  566. & ~REC_1BYTE_SQL_NULL_MASK);
  567. }
  568. /**********************************************************
  569. Returns the offset of nth field start if the record is stored in the 2-byte
  570. offsets form. */
  571. UNIV_INLINE
  572. ulint
  573. rec_2_get_field_start_offs(
  574. /*=======================*/
  575.   /* out: offset of the start of the field */
  576.   rec_t* rec,  /* in: record */
  577.   ulint n) /* in: field index */
  578. {
  579. ut_ad(!rec_get_1byte_offs_flag(rec));
  580. ut_ad(n <= rec_get_n_fields(rec));
  581. if (n == 0) {
  582. return(0);
  583. }
  584. return(rec_2_get_prev_field_end_info(rec, n)
  585. & ~(REC_2BYTE_SQL_NULL_MASK | REC_2BYTE_EXTERN_MASK));
  586. }
  587. /**********************************************************
  588. The following function is used to read the offset of the start of a data field
  589. in the record. The start of an SQL null field is the end offset of the
  590. previous non-null field, or 0, if none exists. If n is the number of the last
  591. field + 1, then the end offset of the last field is returned. */
  592. UNIV_INLINE
  593. ulint
  594. rec_get_field_start_offs(
  595. /*=====================*/
  596.   /* out: offset of the start of the field */
  597.   rec_t* rec,  /* in: record */
  598.   ulint n) /* in: field index */
  599. {
  600. ut_ad(rec);
  601. ut_ad(n <= rec_get_n_fields(rec));
  602. if (n == 0) {
  603. return(0);
  604. }
  605. if (rec_get_1byte_offs_flag(rec)) {
  606. return(rec_1_get_field_start_offs(rec, n));
  607. }
  608. return(rec_2_get_field_start_offs(rec, n));
  609. }
  610. /****************************************************************
  611. Gets the physical size of a field. Also an SQL null may have a field of
  612. size > 0, if the data type is of a fixed size. */
  613. UNIV_INLINE
  614. ulint
  615. rec_get_nth_field_size(
  616. /*===================*/
  617. /* out: field size in bytes */
  618.   rec_t* rec,  /* in: record */
  619.   ulint n) /* in: index of the field */
  620. {
  621. ulint os;
  622. ulint next_os;
  623. os = rec_get_field_start_offs(rec, n);
  624. next_os = rec_get_field_start_offs(rec, n + 1);
  625. ut_ad(next_os - os < UNIV_PAGE_SIZE);
  626. return(next_os - os);
  627. }
  628. /****************************************************************
  629. The following function is used to get a copy of the nth data field in a
  630. record to a buffer. */
  631. UNIV_INLINE
  632. void
  633. rec_copy_nth_field(
  634. /*===============*/
  635.   void* buf, /* in: pointer to the buffer */
  636.   rec_t* rec,  /* in: record */
  637.   ulint n, /* in: index of the field */
  638. ulint* len) /* out: length of the field; UNIV_SQL_NULL if SQL 
  639. null */
  640. {
  641. byte* ptr;
  642. ut_ad(buf && rec && len);
  643. ptr = rec_get_nth_field(rec, n, len);
  644. if (*len == UNIV_SQL_NULL) {
  645. return;
  646. }
  647. ut_memcpy(buf, ptr, *len);
  648. }
  649. /*************************************************************** 
  650. This is used to modify the value of an already existing field in a record.
  651. The previous value must have exactly the same size as the new value. If len
  652. is UNIV_SQL_NULL then the field is treated as an SQL null. */
  653. UNIV_INLINE
  654. void
  655. rec_set_nth_field(
  656. /*==============*/
  657. rec_t* rec,  /* in: record */
  658. ulint n, /* in: index of the field */
  659. void* data, /* in: pointer to the data if not SQL null */
  660. ulint len) /* in: length of the data or UNIV_SQL_NULL */
  661. {
  662. byte* data2;
  663. ulint len2;
  664. ut_ad((len == UNIV_SQL_NULL)
  665. || (rec_get_nth_field_size(rec, n) == len));
  666. if (len == UNIV_SQL_NULL) {
  667. rec_set_nth_field_sql_null(rec, n);
  668. return;
  669. }
  670. data2 = rec_get_nth_field(rec, n, &len2);
  671. ut_memcpy(data2, data, len);
  672. if (len2 == UNIV_SQL_NULL) {
  673. rec_set_nth_field_null_bit(rec, n, FALSE);
  674. }
  675. }
  676. /************************************************************** 
  677. The following function returns the data size of a physical
  678. record, that is the sum of field lengths. SQL null fields
  679. are counted as length 0 fields. The value returned by the function
  680. is the distance from record origin to record end in bytes. */
  681. UNIV_INLINE
  682. ulint
  683. rec_get_data_size(
  684. /*==============*/
  685. /* out: size */
  686. rec_t* rec) /* in: physical record */
  687. {
  688. ut_ad(rec);
  689. return(rec_get_field_start_offs(rec, rec_get_n_fields(rec)));
  690. }
  691. /************************************************************** 
  692. Returns the total size of record minus data size of record. The value
  693. returned by the function is the distance from record start to record origin
  694. in bytes. */
  695. UNIV_INLINE
  696. ulint
  697. rec_get_extra_size(
  698. /*===============*/
  699. /* out: size */
  700. rec_t* rec) /* in: physical record */
  701. {
  702. ulint n_fields;
  703. ut_ad(rec);
  704. n_fields = rec_get_n_fields(rec);
  705. if (rec_get_1byte_offs_flag(rec)) {
  706. return(REC_N_EXTRA_BYTES + n_fields);
  707. }
  708. return(REC_N_EXTRA_BYTES + 2 * n_fields);
  709. }
  710. /************************************************************** 
  711. Returns the total size of a physical record.  */
  712. UNIV_INLINE
  713. ulint
  714. rec_get_size(
  715. /*=========*/
  716. /* out: size */
  717. rec_t* rec) /* in: physical record */
  718. {
  719. ulint n_fields;
  720. ut_ad(rec);
  721. n_fields = rec_get_n_fields(rec);
  722. if (rec_get_1byte_offs_flag(rec)) {
  723. return(REC_N_EXTRA_BYTES + n_fields
  724. + rec_1_get_field_start_offs(rec, n_fields));
  725. }
  726. return(REC_N_EXTRA_BYTES + 2 * n_fields
  727. + rec_2_get_field_start_offs(rec, n_fields));
  728. }
  729. /**************************************************************
  730. Returns a pointer to the end of the record. */
  731. UNIV_INLINE
  732. byte*
  733. rec_get_end(
  734. /*========*/
  735. /* out: pointer to end */
  736. rec_t* rec) /* in: pointer to record */
  737. {
  738. return(rec + rec_get_data_size(rec));
  739. }
  740. /**************************************************************
  741. Returns a pointer to the start of the record. */
  742. UNIV_INLINE
  743. byte*
  744. rec_get_start(
  745. /*==========*/
  746. /* out: pointer to start */
  747. rec_t* rec) /* in: pointer to record */
  748. {
  749. return(rec - rec_get_extra_size(rec));
  750. }
  751. /*******************************************************************
  752. Copies a physical record to a buffer. */
  753. UNIV_INLINE
  754. rec_t*
  755. rec_copy(
  756. /*=====*/
  757. /* out: pointer to the origin of the copied record */
  758. void* buf, /* in: buffer */
  759. rec_t* rec) /* in: physical record */
  760. {
  761. ulint extra_len;
  762. ulint data_len;
  763. ut_ad(rec && buf);
  764. ut_ad(rec_validate(rec));
  765. extra_len = rec_get_extra_size(rec);
  766. data_len = rec_get_data_size(rec);
  767. ut_memcpy(buf, rec - extra_len, extra_len + data_len);
  768. return((byte*)buf + extra_len);
  769. }
  770. /**************************************************************
  771. Returns the extra size of a physical record if we know its data size and
  772. the number of fields. */
  773. UNIV_INLINE
  774. ulint
  775. rec_get_converted_extra_size(
  776. /*=========================*/
  777. /* out: extra size */
  778. ulint data_size, /* in: data size */
  779. ulint n_fields) /* in: number of fields */
  780. {
  781. if (data_size <= REC_1BYTE_OFFS_LIMIT) {
  782. return(REC_N_EXTRA_BYTES + n_fields);
  783. }
  784. return(REC_N_EXTRA_BYTES + 2 * n_fields);
  785. }
  786. /**************************************************************
  787. The following function returns the size of a data tuple when converted to
  788. a physical record. */
  789. UNIV_INLINE
  790. ulint
  791. rec_get_converted_size(
  792. /*===================*/
  793. /* out: size */
  794. dtuple_t* dtuple) /* in: data tuple */
  795. {
  796. ulint data_size;
  797. ulint extra_size;
  798. ut_ad(dtuple);
  799. ut_ad(dtuple_check_typed(dtuple));
  800. data_size = dtuple_get_data_size(dtuple);
  801. extra_size = rec_get_converted_extra_size(
  802. data_size, dtuple_get_n_fields(dtuple));
  803. return(data_size + extra_size);
  804. }
  805. /****************************************************************
  806. Folds a prefix of a physical record to a ulint. Folds only existing fields,
  807. that is, checks that we do not run out of the record. */
  808. UNIV_INLINE
  809. ulint
  810. rec_fold(
  811. /*=====*/
  812. /* out: the folded value */
  813. rec_t* rec, /* in: the physical record */
  814. ulint n_fields, /* in: number of complete fields to fold */
  815. ulint n_bytes, /* in: number of bytes to fold in an
  816. incomplete last field */
  817. dulint tree_id) /* in: index tree id */
  818. {
  819. ulint i;
  820. byte* data;
  821. ulint len;
  822. ulint fold;
  823. ulint n_fields_rec;
  824. ut_ad(rec_validate(rec));
  825. ut_ad(n_fields <= rec_get_n_fields(rec));
  826. ut_ad((n_fields < rec_get_n_fields(rec)) || (n_bytes == 0));
  827. ut_ad(n_fields + n_bytes > 0);
  828. n_fields_rec = rec_get_n_fields(rec);
  829. if (n_fields > n_fields_rec) {
  830.         n_fields = n_fields_rec;
  831. }
  832. if (n_fields == n_fields_rec) {
  833.         n_bytes = 0;
  834. }
  835. fold = ut_fold_dulint(tree_id);
  836. for (i = 0; i < n_fields; i++) {
  837. data = rec_get_nth_field(rec, i, &len);
  838. if (len != UNIV_SQL_NULL) {
  839. fold = ut_fold_ulint_pair(fold,
  840.   ut_fold_binary(data, len));
  841. }
  842. }
  843. if (n_bytes > 0) {
  844. data = rec_get_nth_field(rec, i, &len);
  845. if (len != UNIV_SQL_NULL) {
  846. if (len > n_bytes) {
  847. len = n_bytes;
  848. }
  849. fold = ut_fold_ulint_pair(fold,
  850.   ut_fold_binary(data, len));
  851. }
  852. }
  853. return(fold);
  854. }
  855. /*************************************************************
  856. Builds a physical record out of a data tuple and stores it beginning from
  857. the address destination. */
  858. UNIV_INLINE
  859. rec_t* 
  860. rec_convert_dtuple_to_rec(
  861. /*======================*/
  862. /* out: pointer to the origin of physical
  863. record */
  864. byte* destination, /* in: start address of the physical record */
  865. dtuple_t* dtuple) /* in: data tuple */
  866. {
  867. return(rec_convert_dtuple_to_rec_low(destination, dtuple,
  868. dtuple_get_data_size(dtuple)));
  869. }