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

MySQL数据库

开发平台:

Visual C++

  1. /***********************************************************************
  2. Comparison services for records
  3. (c) 1994-2001 Innobase Oy
  4. Created 7/1/1994 Heikki Tuuri
  5. ************************************************************************/
  6. #ifndef rem0cmp_h
  7. #define rem0cmp_h
  8. #include "univ.i"
  9. #include "data0data.h"
  10. #include "data0type.h"
  11. #include "dict0dict.h"
  12. #include "rem0rec.h"
  13. /*****************************************************************
  14. Returns TRUE if two types are equal for comparison purposes. */
  15. ibool
  16. cmp_types_are_equal(
  17. /*================*/
  18. /* out: TRUE if the types are considered
  19. equal in comparisons */
  20. dtype_t* type1, /* in: type 1 */
  21. dtype_t* type2); /* in: type 2 */
  22. /*****************************************************************
  23. This function is used to compare two data fields for which we know the
  24. data type. */
  25. UNIV_INLINE
  26. int
  27. cmp_data_data(
  28. /*==========*/
  29. /* out: 1, 0, -1, if data1 is greater, equal, 
  30. less than data2, respectively */
  31. dtype_t* cur_type,/* in: data type of the fields */
  32. byte* data1, /* in: data field (== a pointer to a memory
  33. buffer) */
  34. ulint len1, /* in: data field length or UNIV_SQL_NULL */
  35. byte* data2, /* in: data field (== a pointer to a memory
  36. buffer) */
  37. ulint len2); /* in: data field length or UNIV_SQL_NULL */
  38. /*****************************************************************
  39. This function is used to compare two data fields for which we know the
  40. data type. */
  41. int
  42. cmp_data_data_slow(
  43. /*===============*/
  44. /* out: 1, 0, -1, if data1 is greater, equal, 
  45. less than data2, respectively */
  46. dtype_t* cur_type,/* in: data type of the fields */
  47. byte* data1, /* in: data field (== a pointer to a memory
  48. buffer) */
  49. ulint len1, /* in: data field length or UNIV_SQL_NULL */
  50. byte* data2, /* in: data field (== a pointer to a memory
  51. buffer) */
  52. ulint len2); /* in: data field length or UNIV_SQL_NULL */
  53. /*****************************************************************
  54. This function is used to compare two dfields where at least the first
  55. has its data type field set. */
  56. UNIV_INLINE
  57. int
  58. cmp_dfield_dfield(
  59. /*==============*/
  60. /* out: 1, 0, -1, if dfield1 is greater, equal, 
  61. less than dfield2, respectively */
  62. dfield_t* dfield1,/* in: data field; must have type field set */
  63. dfield_t* dfield2);/* in: data field */
  64. /*****************************************************************
  65. This function is used to compare a data tuple to a physical record.
  66. Only dtuple->n_fields_cmp first fields are taken into account for
  67. the the data tuple! If we denote by n = n_fields_cmp, then rec must
  68. have either m >= n fields, or it must differ from dtuple in some of
  69. the m fields rec has. If rec has an externally stored field we do not
  70. compare it but return with value 0 if such a comparison should be
  71. made. */
  72. int
  73. cmp_dtuple_rec_with_match(
  74. /*======================*/
  75. /* out: 1, 0, -1, if dtuple is greater, equal, 
  76. less than rec, respectively, when only the 
  77. common first fields are compared, or
  78. until the first externally stored field in
  79. rec */
  80. dtuple_t* dtuple, /* in: data tuple */
  81. rec_t* rec, /* in: physical record which differs from
  82. dtuple in some of the common fields, or which
  83. has an equal number or more fields than
  84. dtuple */
  85. ulint*   matched_fields, /* in/out: number of already completely 
  86. matched fields; when function returns,
  87. contains the value for current comparison */
  88. ulint*    matched_bytes); /* in/out: number of already matched 
  89. bytes within the first field not completely
  90. matched; when function returns, contains the
  91. value for current comparison */
  92. /******************************************************************
  93. Compares a data tuple to a physical record. */
  94. int
  95. cmp_dtuple_rec(
  96. /*===========*/
  97. /* out: 1, 0, -1, if dtuple is greater, equal, 
  98. less than rec, respectively; see the comments
  99. for cmp_dtuple_rec_with_match */
  100. dtuple_t*  dtuple, /* in: data tuple */
  101. rec_t*    rec); /* in: physical record */
  102. /******************************************************************
  103. Checks if a dtuple is a prefix of a record. The last field in dtuple
  104. is allowed to be a prefix of the corresponding field in the record. */
  105. ibool
  106. cmp_dtuple_is_prefix_of_rec(
  107. /*========================*/
  108. /* out: TRUE if prefix */
  109. dtuple_t*  dtuple, /* in: data tuple */
  110. rec_t*    rec); /* in: physical record */
  111. /******************************************************************
  112. Compares a prefix of a data tuple to a prefix of a physical record for
  113. equality. If there are less fields in rec than parameter n_fields, FALSE
  114. is returned. NOTE that n_fields_cmp of dtuple does not affect this
  115. comparison. */
  116. ibool
  117. cmp_dtuple_rec_prefix_equal(
  118. /*========================*/
  119. /* out: TRUE if equal */
  120. dtuple_t* dtuple, /* in: data tuple */
  121. rec_t* rec, /* in: physical record */
  122. ulint n_fields); /* in: number of fields which should be 
  123. compared; must not exceed the number of 
  124. fields in dtuple */
  125. /*****************************************************************
  126. This function is used to compare two physical records. Only the common
  127. first fields are compared, and if an externally stored field is
  128. encountered, then 0 is returned. */
  129. int
  130. cmp_rec_rec_with_match(
  131. /*===================*/
  132. /* out: 1, 0 , -1 if rec1 is greater, equal,
  133. less, respectively, than rec2; only the common
  134. first fields are compared */
  135. rec_t* rec1, /* in: physical record */
  136. rec_t* rec2, /* in: physical record */
  137. dict_index_t* index, /* in: data dictionary index */
  138. ulint*   matched_fields, /* in/out: number of already completely 
  139. matched fields; when the function returns,
  140. contains the value the for current
  141. comparison */
  142. ulint*    matched_bytes);/* in/out: number of already matched 
  143. bytes within the first field not completely
  144. matched; when the function returns, contains
  145. the value for the current comparison */
  146. /*****************************************************************
  147. This function is used to compare two physical records. Only the common
  148. first fields are compared. */
  149. UNIV_INLINE
  150. int
  151. cmp_rec_rec(
  152. /*========*/
  153. /* out: 1, 0 , -1 if rec1 is greater, equal,
  154. less, respectively, than rec2; only the common
  155. first fields are compared */
  156. rec_t* rec1, /* in: physical record */
  157. rec_t* rec2, /* in: physical record */
  158. dict_index_t* index); /* in: data dictionary index */
  159. #ifndef UNIV_NONINL
  160. #include "rem0cmp.ic"
  161. #endif
  162. #endif