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

MySQL数据库

开发平台:

Visual C++

  1. /******************************************************
  2. General row routines
  3. (c) 1996 Innobase Oy
  4. Created 4/20/1996 Heikki Tuuri
  5. *******************************************************/
  6. #ifndef row0row_h
  7. #define row0row_h
  8. #include "univ.i"
  9. #include "data0data.h"
  10. #include "dict0types.h"
  11. #include "trx0types.h"
  12. #include "que0types.h"
  13. #include "mtr0mtr.h"
  14. #include "rem0types.h"
  15. #include "read0types.h"
  16. #include "btr0types.h"
  17. /*************************************************************************
  18. Reads the trx id field from a clustered index record. */
  19. UNIV_INLINE
  20. dulint
  21. row_get_rec_trx_id(
  22. /*===============*/
  23. /* out: value of the field */
  24. rec_t* rec, /* in: record */
  25. dict_index_t* index); /* in: clustered index */
  26. /*************************************************************************
  27. Reads the roll pointer field from a clustered index record. */
  28. UNIV_INLINE
  29. dulint
  30. row_get_rec_roll_ptr(
  31. /*=================*/
  32. /* out: value of the field */
  33. rec_t* rec, /* in: record */
  34. dict_index_t* index); /* in: clustered index */
  35. /*************************************************************************
  36. Writes the trx id field to a clustered index record. */
  37. UNIV_INLINE
  38. void
  39. row_set_rec_trx_id(
  40. /*===============*/
  41. rec_t* rec, /* in: record */
  42. dict_index_t* index, /* in: clustered index */
  43. dulint trx_id); /* in: value of the field */
  44. /*************************************************************************
  45. Sets the roll pointer field in a clustered index record. */
  46. UNIV_INLINE
  47. void
  48. row_set_rec_roll_ptr(
  49. /*=================*/
  50. rec_t* rec, /* in: record */
  51. dict_index_t* index, /* in: clustered index */
  52. dulint roll_ptr);/* in: value of the field */
  53. /*********************************************************************
  54. When an insert to a table is performed, this function builds the entry which
  55. has to be inserted to an index on the table. */
  56. dtuple_t*
  57. row_build_index_entry(
  58. /*==================*/
  59. /* out: index entry which should be inserted */
  60. dtuple_t* row,  /* in: row which should be inserted to the
  61. table */
  62. dict_index_t* index,  /* in: index on the table */
  63. mem_heap_t* heap); /* in: memory heap from which the memory for
  64. the index entry is allocated */
  65. /***********************************************************************
  66. An inverse function to dict_row_build_index_entry. Builds a row from a
  67. record in a clustered index. */
  68. dtuple_t*
  69. row_build(
  70. /*======*/
  71. /* out, own: row built; see the NOTE below! */
  72. ulint type, /* in: ROW_COPY_POINTERS, ROW_COPY_DATA, or
  73. ROW_COPY_ALSO_EXTERNALS, 
  74. the two last copy also the data fields to
  75. heap as the first only places pointers to
  76. data fields on the index page, and thus is
  77. more efficient */
  78. dict_index_t* index, /* in: clustered index */
  79. rec_t* rec, /* in: record in the clustered index;
  80. NOTE: in the case ROW_COPY_POINTERS
  81. the data fields in the row will point
  82. directly into this record, therefore,
  83. the buffer page of this record must be
  84. at least s-latched and the latch held
  85. as long as the row dtuple is used! */
  86. mem_heap_t* heap); /* in: memory heap from which the memory
  87. needed is allocated */
  88. /***********************************************************************
  89. Converts an index record to a typed data tuple. */
  90. dtuple_t*
  91. row_rec_to_index_entry(
  92. /*===================*/
  93. /* out, own: index entry built; see the
  94. NOTE below! */
  95. ulint type, /* in: ROW_COPY_DATA, or ROW_COPY_POINTERS:
  96. the former copies also the data fields to
  97. heap as the latter only places pointers to
  98. data fields on the index page */
  99. dict_index_t* index, /* in: index */
  100. rec_t* rec, /* in: record in the index;
  101. NOTE: in the case ROW_COPY_POINTERS
  102. the data fields in the row will point
  103. directly into this record, therefore,
  104. the buffer page of this record must be
  105. at least s-latched and the latch held
  106. as long as the dtuple is used! */
  107. mem_heap_t* heap); /* in: memory heap from which the memory
  108. needed is allocated */
  109. /***********************************************************************
  110. Builds from a secondary index record a row reference with which we can
  111. search the clustered index record. */
  112. dtuple_t*
  113. row_build_row_ref(
  114. /*==============*/
  115. /* out, own: row reference built; see the
  116. NOTE below! */
  117. ulint type, /* in: ROW_COPY_DATA, or ROW_COPY_POINTERS:
  118. the former copies also the data fields to
  119. heap, whereas the latter only places pointers
  120. to data fields on the index page */
  121. dict_index_t* index, /* in: index */
  122. rec_t* rec, /* in: record in the index;
  123. NOTE: in the case ROW_COPY_POINTERS
  124. the data fields in the row will point
  125. directly into this record, therefore,
  126. the buffer page of this record must be
  127. at least s-latched and the latch held
  128. as long as the row reference is used! */
  129. mem_heap_t* heap); /* in: memory heap from which the memory
  130. needed is allocated */
  131. /***********************************************************************
  132. Builds from a secondary index record a row reference with which we can
  133. search the clustered index record. */
  134. void
  135. row_build_row_ref_in_tuple(
  136. /*=======================*/
  137. dtuple_t* ref, /* in/out: row reference built; see the
  138. NOTE below! */
  139. dict_index_t* index, /* in: index */
  140. rec_t* rec, /* in: record in the index;
  141. NOTE: the data fields in ref will point
  142. directly into this record, therefore,
  143. the buffer page of this record must be
  144. at least s-latched and the latch held
  145. as long as the row reference is used! */
  146. trx_t* trx); /* in: transaction */
  147. /***********************************************************************
  148. From a row build a row reference with which we can search the clustered
  149. index record. */
  150. void
  151. row_build_row_ref_from_row(
  152. /*=======================*/
  153. dtuple_t* ref, /* in/out: row reference built; see the
  154. NOTE below! ref must have the right number
  155. of fields! */
  156. dict_table_t* table, /* in: table */
  157. dtuple_t* row); /* in: row
  158. NOTE: the data fields in ref will point
  159. directly into data of this row */
  160. /***********************************************************************
  161. Builds from a secondary index record a row reference with which we can
  162. search the clustered index record. */
  163. UNIV_INLINE
  164. void
  165. row_build_row_ref_fast(
  166. /*===================*/
  167. dtuple_t* ref, /* in: typed data tuple where the reference
  168. is built */
  169. ulint* map, /* in: array of field numbers in rec telling
  170. how ref should be built from the fields of
  171. rec */
  172. rec_t* rec); /* in: record in the index; must be preserved
  173. while ref is used, as we do not copy field
  174. values to heap */
  175. /*******************************************************************
  176. Searches the clustered index record for a row, if we have the row
  177. reference. */
  178. ibool
  179. row_search_on_row_ref(
  180. /*==================*/
  181. /* out: TRUE if found */
  182. btr_pcur_t* pcur, /* in/out: persistent cursor, which must
  183. be closed by the caller */
  184. ulint mode, /* in: BTR_MODIFY_LEAF, ... */
  185. dict_table_t* table, /* in: table */
  186. dtuple_t* ref, /* in: row reference */
  187. mtr_t* mtr); /* in: mtr */
  188. /*************************************************************************
  189. Fetches the clustered index record for a secondary index record. The latches
  190. on the secondary index record are preserved. */
  191. rec_t*
  192. row_get_clust_rec(
  193. /*==============*/
  194. /* out: record or NULL, if no record found */
  195. ulint mode, /* in: BTR_MODIFY_LEAF, ... */
  196. rec_t* rec, /* in: record in a secondary index */
  197. dict_index_t* index, /* in: secondary index */
  198. dict_index_t** clust_index,/* out: clustered index */
  199. mtr_t* mtr); /* in: mtr */
  200. /*******************************************************************
  201. Searches an index record. */
  202. ibool
  203. row_search_index_entry(
  204. /*===================*/
  205. /* out: TRUE if found */
  206. dict_index_t* index, /* in: index */
  207. dtuple_t* entry, /* in: index entry */
  208. ulint mode, /* in: BTR_MODIFY_LEAF, ... */
  209. btr_pcur_t* pcur, /* in/out: persistent cursor, which must
  210. be closed by the caller */
  211. mtr_t* mtr); /* in: mtr */
  212. #define ROW_COPY_DATA 1
  213. #define ROW_COPY_POINTERS 2
  214. #define ROW_COPY_ALSO_EXTERNALS 3
  215. /* The allowed latching order of index records is the following:
  216. (1) a secondary index record ->
  217. (2) the clustered index record ->
  218. (3) rollback segment data for the clustered index record.
  219. No new latches may be obtained while the kernel mutex is reserved.
  220. However, the kernel mutex can be reserved while latches are owned. */
  221. #ifndef UNIV_NONINL
  222. #include "row0row.ic"
  223. #endif
  224. #endif