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

MySQL数据库

开发平台:

Visual C++

  1. /************************************************************************
  2. Record manager
  3. (c) 1994-2001 Innobase Oy
  4. Created 5/30/1994 Heikki Tuuri
  5. *************************************************************************/
  6. #include "rem0rec.h"
  7. #ifdef UNIV_NONINL
  8. #include "rem0rec.ic"
  9. #endif
  10. #include "mtr0mtr.h"
  11. #include "mtr0log.h"
  12. /* PHYSICAL RECORD
  13. ===============
  14. The physical record, which is the data type of all the records
  15. found in index pages of the database, has the following format
  16. (lower addresses and more significant bits inside a byte are below
  17. represented on a higher text line):
  18. | offset of the end of the last field of data, the most significant
  19.   bit is set to 1 if and only if the field is SQL-null,
  20.   if the offset is 2-byte, then the second most significant
  21.   bit is set to 1 if the field is stored on another page:
  22.   mostly this will occur in the case of big BLOB fields |
  23. ... 
  24. | offset of the end of the first field of data + the SQL-null bit |
  25. | 4 bits used to delete mark a record, and mark a predefined
  26.   minimum record in alphabetical order |
  27. | 4 bits giving the number of records owned by this record
  28.   (this term is explained in page0page.h) |
  29. | 13 bits giving the order number of this record in the
  30.   heap of the index page |
  31. | 10 bits giving the number of fields in this record |
  32. | 1 bit which is set to 1 if the offsets above are given in
  33.   one byte format, 0 if in two byte format |
  34. | two bytes giving the pointer to the next record in the page | 
  35. ORIGIN of the record
  36. | first field of data | 
  37. ... 
  38. | last field of data |
  39. The origin of the record is the start address of the first field 
  40. of data. The offsets are given relative to the origin. 
  41. The offsets of the data fields are stored in an inverted
  42. order because then the offset of the first fields are near the 
  43. origin, giving maybe a better processor cache hit rate in searches.
  44. The offsets of the data fields are given as one-byte 
  45. (if there are less than 127 bytes of data in the record) 
  46. or two-byte unsigned integers. The most significant bit
  47. is not part of the offset, instead it indicates the SQL-null
  48. if the bit is set to 1.
  49. CANONICAL COORDINATES. A record can be seen as a single
  50. string of 'characters' in the following way: catenate the bytes
  51. in each field, in the order of fields. An SQL-null field
  52. is taken to be an empty sequence of bytes. Then after
  53. the position of each field insert in the string 
  54. the 'character' <FIELD-END>, except that after an SQL-null field
  55. insert <NULL-FIELD-END>. Now the ordinal position of each
  56. byte in this canonical string is its canonical coordinate.
  57. So, for the record ("AA", SQL-NULL, "BB", ""), the canonical
  58. string is "AA<FIELD_END><NULL-FIELD-END>BB<FIELD-END><FIELD-END>".
  59. We identify prefixes (= initial segments) of a record
  60. with prefixes of the canonical string. The canonical
  61. length of the prefix is the length of the corresponding
  62. prefix of the canonical string. The canonical length of
  63. a record is the length of its canonical string.
  64. For example, the maximal common prefix of records
  65. ("AA", SQL-NULL, "BB", "C") and ("AA", SQL-NULL, "B", "C")
  66. is "AA<FIELD-END><NULL-FIELD-END>B", and its canonical
  67. length is 5.
  68. A complete-field prefix of a record is a prefix which ends at the
  69. end of some field (containing also <FIELD-END>).
  70. A record is a complete-field prefix of another record, if
  71. the corresponding canonical strings have the same property. */
  72. ulint rec_dummy; /* this is used to fool compiler in
  73. rec_validate */
  74. /****************************************************************
  75. The following function is used to get a pointer to the nth data field in a
  76. record. */
  77. byte*
  78. rec_get_nth_field(
  79. /*==============*/
  80.   /* out: pointer to the field */
  81.   rec_t* rec,  /* in: record */
  82.   ulint n, /* in: index of the field */
  83. ulint* len) /* out: length of the field; UNIV_SQL_NULL if SQL
  84. null */
  85. {
  86. ulint os;
  87. ulint next_os;
  88. ut_ad(rec && len);
  89. ut_ad(n < rec_get_n_fields(rec));
  90. if (n > 1024) {
  91. fprintf(stderr, "Error: trying to access field %lu in recn",
  92. (ulong) n);
  93. ut_error;
  94. }
  95. if (rec == NULL) {
  96. fputs("Error: rec is NULL pointern", stderr);
  97. ut_error;
  98. }
  99. if (rec_get_1byte_offs_flag(rec)) {
  100. os = rec_1_get_field_start_offs(rec, n);
  101. next_os = rec_1_get_field_end_info(rec, n);
  102. if (next_os & REC_1BYTE_SQL_NULL_MASK) {
  103. *len = UNIV_SQL_NULL;
  104. return(rec + os);
  105. }
  106. next_os = next_os & ~REC_1BYTE_SQL_NULL_MASK;
  107. } else {
  108. os = rec_2_get_field_start_offs(rec, n);
  109. next_os = rec_2_get_field_end_info(rec, n);
  110. if (next_os & REC_2BYTE_SQL_NULL_MASK) {
  111. *len = UNIV_SQL_NULL;
  112. return(rec + os);
  113. }
  114. next_os = next_os & ~(REC_2BYTE_SQL_NULL_MASK
  115. | REC_2BYTE_EXTERN_MASK);
  116. }
  117. *len = next_os - os;
  118. ut_ad(*len < UNIV_PAGE_SIZE);
  119. return(rec + os);
  120. }
  121. /***************************************************************
  122. Sets the value of the ith field SQL null bit. */
  123. void
  124. rec_set_nth_field_null_bit(
  125. /*=======================*/
  126. rec_t* rec, /* in: record */
  127. ulint i, /* in: ith field */
  128. ibool val) /* in: value to set */
  129. {
  130. ulint info;
  131. if (rec_get_1byte_offs_flag(rec)) {
  132. info = rec_1_get_field_end_info(rec, i);
  133. if (val) {
  134. info = info | REC_1BYTE_SQL_NULL_MASK;
  135. } else {
  136. info = info & ~REC_1BYTE_SQL_NULL_MASK;
  137. }
  138. rec_1_set_field_end_info(rec, i, info);
  139. return;
  140. }
  141. info = rec_2_get_field_end_info(rec, i);
  142. if (val) {
  143. info = info | REC_2BYTE_SQL_NULL_MASK;
  144. } else {
  145. info = info & ~REC_2BYTE_SQL_NULL_MASK;
  146. }
  147. rec_2_set_field_end_info(rec, i, info);
  148. }
  149. /***************************************************************
  150. Sets the value of the ith field extern storage bit. */
  151. void
  152. rec_set_nth_field_extern_bit(
  153. /*=========================*/
  154. rec_t* rec, /* in: record */
  155. ulint i, /* in: ith field */
  156. ibool val, /* in: value to set */
  157. mtr_t* mtr) /* in: mtr holding an X-latch to the page where
  158. rec is, or NULL; in the NULL case we do not
  159. write to log about the change */
  160. {
  161. ulint info;
  162. ut_a(!rec_get_1byte_offs_flag(rec));
  163. ut_a(i < rec_get_n_fields(rec));
  164. info = rec_2_get_field_end_info(rec, i);
  165. if (val) {
  166. info = info | REC_2BYTE_EXTERN_MASK;
  167. } else {
  168. info = info & ~REC_2BYTE_EXTERN_MASK;
  169. }
  170. if (mtr) {
  171. mlog_write_ulint(rec - REC_N_EXTRA_BYTES - 2 * (i + 1), info,
  172. MLOG_2BYTES, mtr);
  173. } else {
  174. rec_2_set_field_end_info(rec, i, info);
  175. }
  176. }
  177. /***************************************************************
  178. Sets TRUE the extern storage bits of fields mentioned in an array. */
  179. void
  180. rec_set_field_extern_bits(
  181. /*======================*/
  182. rec_t* rec, /* in: record */
  183. ulint* vec, /* in: array of field numbers */
  184. ulint n_fields, /* in: number of fields numbers */
  185. mtr_t* mtr) /* in: mtr holding an X-latch to the page
  186. where rec is, or NULL; in the NULL case we
  187. do not write to log about the change */
  188. {
  189. ulint i;
  190. for (i = 0; i < n_fields; i++) {
  191. rec_set_nth_field_extern_bit(rec, vec[i], TRUE, mtr);
  192. }
  193. }
  194. /*************************************************************** 
  195. Sets a record field to SQL null. The physical size of the field is not
  196. changed. */
  197. void
  198. rec_set_nth_field_sql_null(
  199. /*=======================*/
  200. rec_t* rec,  /* in: record */
  201. ulint n) /* in: index of the field */
  202. {
  203. ulint offset;
  204. offset = rec_get_field_start_offs(rec, n);
  205. data_write_sql_null(rec + offset, rec_get_nth_field_size(rec, n));
  206. rec_set_nth_field_null_bit(rec, n, TRUE);
  207. }
  208. /*************************************************************
  209. Builds a physical record out of a data tuple and stores it beginning from
  210. address destination. */
  211. rec_t* 
  212. rec_convert_dtuple_to_rec_low(
  213. /*==========================*/
  214. /* out: pointer to the origin of physical
  215. record */
  216. byte* destination, /* in: start address of the physical record */
  217. dtuple_t* dtuple, /* in: data tuple */
  218. ulint data_size) /* in: data size of dtuple */
  219. {
  220. dfield_t*  field;
  221. ulint n_fields;
  222. rec_t*  rec;
  223. ulint end_offset;
  224. ulint ored_offset;
  225. byte* data;
  226. ulint len;
  227. ulint i;
  228. ut_ad(destination && dtuple);
  229. ut_ad(dtuple_validate(dtuple));
  230. ut_ad(dtuple_check_typed(dtuple));
  231. ut_ad(dtuple_get_data_size(dtuple) == data_size);
  232. n_fields = dtuple_get_n_fields(dtuple);
  233. ut_ad(n_fields > 0);
  234. /* Calculate the offset of the origin in the physical record */
  235. rec = destination + rec_get_converted_extra_size(data_size, n_fields);
  236. /* Store the number of fields */
  237. rec_set_n_fields(rec, n_fields);
  238. /* Set the info bits of the record */
  239. rec_set_info_bits(rec, dtuple_get_info_bits(dtuple));
  240. /* Store the data and the offsets */
  241. end_offset = 0;
  242. if (data_size <= REC_1BYTE_OFFS_LIMIT) {
  243.     rec_set_1byte_offs_flag(rec, TRUE);
  244.     for (i = 0; i < n_fields; i++) {
  245. field = dtuple_get_nth_field(dtuple, i);
  246. data = dfield_get_data(field);
  247. len = dfield_get_len(field);
  248. if (len == UNIV_SQL_NULL) {
  249. len = dtype_get_sql_null_size(dfield_get_type(field));
  250. data_write_sql_null(rec + end_offset, len);
  251. end_offset += len;
  252. ored_offset = end_offset | REC_1BYTE_SQL_NULL_MASK;
  253. } else {
  254. /* If the data is not SQL null, store it */
  255. ut_memcpy(rec + end_offset, data, len);
  256. end_offset += len;
  257. ored_offset = end_offset;
  258. }
  259. rec_1_set_field_end_info(rec, i, ored_offset);
  260.     }
  261. } else {
  262.     rec_set_1byte_offs_flag(rec, FALSE);
  263.     for (i = 0; i < n_fields; i++) {
  264. field = dtuple_get_nth_field(dtuple, i);
  265. data = dfield_get_data(field);
  266. len = dfield_get_len(field);
  267. if (len == UNIV_SQL_NULL) {
  268. len = dtype_get_sql_null_size(dfield_get_type(field));
  269. data_write_sql_null(rec + end_offset, len);
  270. end_offset += len;
  271. ored_offset = end_offset | REC_2BYTE_SQL_NULL_MASK;
  272. } else {
  273. /* If the data is not SQL null, store it */
  274. ut_memcpy(rec + end_offset, data, len);
  275. end_offset += len;
  276. ored_offset = end_offset;
  277. }
  278. rec_2_set_field_end_info(rec, i, ored_offset);
  279.     }
  280. }
  281. ut_ad(rec_validate(rec));
  282. return(rec);
  283. }
  284. /******************************************************************
  285. Copies the first n fields of a physical record to a data tuple. The fields
  286. are copied to the memory heap. */
  287. void
  288. rec_copy_prefix_to_dtuple(
  289. /*======================*/
  290. dtuple_t* tuple, /* in: data tuple */
  291. rec_t* rec, /* in: physical record */
  292. ulint n_fields, /* in: number of fields to copy */
  293. mem_heap_t* heap) /* in: memory heap */
  294. {
  295. dfield_t* field;
  296. byte* data;
  297. ulint len;
  298. byte* buf = NULL;
  299. ulint i;
  300. ut_ad(rec_validate(rec));
  301. ut_ad(dtuple_check_typed(tuple));
  302. dtuple_set_info_bits(tuple, rec_get_info_bits(rec));
  303. for (i = 0; i < n_fields; i++) {
  304. field = dtuple_get_nth_field(tuple, i);
  305. data = rec_get_nth_field(rec, i, &len);
  306. if (len != UNIV_SQL_NULL) {
  307. buf = mem_heap_alloc(heap, len);
  308. ut_memcpy(buf, data, len);
  309. }
  310. dfield_set_data(field, buf, len);
  311. }
  312. }
  313. /******************************************************************
  314. Copies the first n fields of a physical record to a new physical record in
  315. a buffer. */
  316. rec_t*
  317. rec_copy_prefix_to_buf(
  318. /*===================*/
  319. /* out, own: copied record */
  320. rec_t* rec, /* in: physical record */
  321. ulint n_fields, /* in: number of fields to copy */
  322. byte** buf, /* in/out: memory buffer for the copied prefix,
  323. or NULL */
  324. ulint* buf_size) /* in/out: buffer size */
  325. {
  326. rec_t* copy_rec;
  327. ulint area_start;
  328. ulint area_end;
  329. ulint prefix_len;
  330. ut_ad(rec_validate(rec));
  331. area_end = rec_get_field_start_offs(rec, n_fields);
  332. if (rec_get_1byte_offs_flag(rec)) {
  333. area_start = REC_N_EXTRA_BYTES + n_fields;
  334. } else {
  335. area_start = REC_N_EXTRA_BYTES + 2 * n_fields;
  336. }
  337. prefix_len = area_start + area_end;
  338. if ((*buf == NULL) || (*buf_size < prefix_len)) {
  339. if (*buf != NULL) {
  340. mem_free(*buf);
  341. }
  342. *buf = mem_alloc(prefix_len);
  343. *buf_size = prefix_len;
  344. }
  345. ut_memcpy(*buf, rec - area_start, prefix_len);
  346. copy_rec = *buf + area_start;
  347. rec_set_n_fields(copy_rec, n_fields);
  348. return(copy_rec);
  349. }
  350. /*******************************************************************
  351. Validates the consistency of a physical record. */
  352. ibool
  353. rec_validate(
  354. /*=========*/
  355. /* out: TRUE if ok */
  356. rec_t* rec) /* in: physical record */
  357. {
  358. byte* data;
  359. ulint len;
  360. ulint n_fields;
  361. ulint len_sum = 0;
  362. ulint sum = 0;
  363. ulint i;
  364. ut_a(rec);
  365. n_fields = rec_get_n_fields(rec);
  366. if ((n_fields == 0) || (n_fields > REC_MAX_N_FIELDS)) {
  367. fprintf(stderr, "InnoDB: Error: record has %lu fieldsn",
  368. (ulong) n_fields);
  369. return(FALSE);
  370. }
  371. for (i = 0; i < n_fields; i++) {
  372. data = rec_get_nth_field(rec, i, &len);
  373. if (!((len < UNIV_PAGE_SIZE) || (len == UNIV_SQL_NULL))) {
  374. fprintf(stderr,
  375. "InnoDB: Error: record field %lu len %lun", (ulong) i,
  376. (ulong) len);
  377. return(FALSE);
  378. }
  379. if (len != UNIV_SQL_NULL) {
  380. len_sum += len;
  381. sum += *(data + len -1); /* dereference the
  382. end of the field to
  383. cause a memory trap
  384. if possible */
  385. } else {
  386. len_sum += rec_get_nth_field_size(rec, i);
  387. }
  388. }
  389. if (len_sum != (ulint)(rec_get_end(rec) - rec)) {
  390. fprintf(stderr,
  391. "InnoDB: Error: record len should be %lu, len %lun",
  392. (ulong) len_sum,
  393.         (ulong) (rec_get_end(rec) - rec));
  394. return(FALSE);
  395. }
  396. rec_dummy = sum; /* This is here only to fool the compiler */
  397. return(TRUE);
  398. }
  399. /*******************************************************************
  400. Prints a physical record. */
  401. void
  402. rec_print(
  403. /*======*/
  404. FILE* file, /* in: file where to print */
  405. rec_t* rec) /* in: physical record */
  406. {
  407. byte* data;
  408. ulint len;
  409. ulint n;
  410. ulint i;
  411. ut_ad(rec);
  412. n = rec_get_n_fields(rec);
  413. fprintf(file, "PHYSICAL RECORD: n_fields %lu;"
  414. " 1-byte offs %s; info bits %lun",
  415. (ulong) n, rec_get_1byte_offs_flag(rec) ? "TRUE" : "FALSE",
  416. (ulong) rec_get_info_bits(rec));
  417. for (i = 0; i < n; i++) {
  418. data = rec_get_nth_field(rec, i, &len);
  419. fprintf(file, " %lu:", (ulong) i);
  420. if (len != UNIV_SQL_NULL) {
  421. if (len <= 30) {
  422. ut_print_buf(file, data, len);
  423. } else {
  424. ut_print_buf(file, data, 30);
  425. fputs("...(truncated)", file);
  426. }
  427. } else {
  428. fprintf(file, " SQL NULL, size %lu ",
  429.       (ulong) rec_get_nth_field_size(rec, i));
  430. }
  431. putc(';', file);
  432. }
  433. putc('n', file);
  434. rec_validate(rec);
  435. }