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

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

MySQL数据库

开发平台：

Visual C++

rem0cmp.c：源码内容
  1. /***********************************************************************
  2. Comparison services for records
  4. (c) 1994-1996 Innobase Oy
  6. Created 7/1/1994 Heikki Tuuri
  7. ************************************************************************/
  9. #include "rem0cmp.h"
  11. #ifdef UNIV_NONINL
  12. #include "rem0cmp.ic"
  13. #endif
  15. /* ALPHABETICAL ORDER
  16. ==================
  18. The records are put into alphabetical order in the following
  19. way: let F be the first field where two records disagree.
  20. If there is a character in some position n where the the
  21. records disagree, the order is determined by comparison of
  22. the characters at position n, possibly after
  23. collating transformation. If there is no such character,
  24. but the corresponding fields have different lengths, then
  25. if the data type of the fields is paddable,
  26. shorter field is padded with a padding character. If the
  27. data type is not paddable, longer field is considered greater.
  28. Finally, the SQL null is bigger than any other value.
  30. At the present, the comparison functions return 0 in the case,
  31. where two records disagree only in the way that one 
  32. has more fields than the other. */
  34. /*****************************************************************
  35. Used in debug checking of cmp_dtuple_... .
  36. This function is used to compare a data tuple to a physical record. If
  37. dtuple has n fields then rec must have either m >= n fields, or it must
  38. differ from dtuple in some of the m fields rec has. */
  39. static
  40. int
  41. cmp_debug_dtuple_rec_with_match(
  42. /*============================*/
  43. /* out: 1, 0, -1, if dtuple is greater, equal, 
  44. less than rec, respectively, when only the 
  45. common first fields are compared */
  46. dtuple_t* dtuple, /* in: data tuple */
  47. rec_t* rec, /* in: physical record which differs from
  48. dtuple in some of the common fields, or which
  49. has an equal number or more fields than
  50. dtuple */
  51. ulint*   matched_fields);/* in/out: number of already completely 
  52. matched fields; when function returns,
  53. contains the value for current comparison */
  54. /*****************************************************************
  55. This function is used to compare two data fields for which the data type
  56. is such that we must use MySQL code to compare them. */
  58. int
  59. innobase_mysql_cmp(
  60. /*===============*/
  61. /* out: 1, 0, -1, if a is greater,
  62. equal, less than b, respectively */
  63. int mysql_type, /* in: MySQL type */ 
  64. unsigned char* a, /* in: data field */
  65. unsigned int a_length, /* in: data field length,
  66. not UNIV_SQL_NULL */
  67. unsigned char* b, /* in: data field */
  68. unsigned int b_length); /* in: data field length,
  69. not UNIV_SQL_NULL */
  71. /*****************************************************************
  72. Innobase uses this function is to compare two data fields for which the
  73. data type is such that we must compare whole fields. */
  74. static
  75. int
  76. cmp_whole_field(
  77. /*============*/
  78. /* out: 1, 0, -1, if a is greater,
  79. equal, less than b, respectively */
  80. dtype_t* type, /* in: data type */
  81. unsigned char* a, /* in: data field */
  82. unsigned int a_length, /* in: data field length,
  83. not UNIV_SQL_NULL */
  84. unsigned char* b, /* in: data field */
  85. unsigned int b_length) /* in: data field length,
  86. not UNIV_SQL_NULL */
  87. {
  88. float f_1;
  89. float f_2;
  90. double d_1;
  91. double d_2;
  92. int swap_flag = 1;
  93. ulint data_type;
  95. data_type = type->mtype;
  97. switch (data_type) {
  99.      case DATA_DECIMAL:
  100. /* Remove preceding spaces */
  101. for (; a_length && *a == ' '; a++, a_length--);
  102. for (; b_length && *b == ' '; b++, b_length--);
  104.        if (*a == '-') {
  105. if (*b != '-') {
  106.    return(-1);
  107.    }
  109. a++; b++;
  110. a_length--;
  111. b_length--;
  113. swap_flag = -1;
  115.        } else if (*b == '-') {
  117. return(1);
  118. }
  120.        while (a_length > 0 && (*a == '+' || *a == '0')) {
  121. a++; a_length--;
  122.        }
  124.        while (b_length > 0 && (*b == '+' || *b == '0')) {
  125. b++; b_length--;
  126.        }
  127.       
  128.        if (a_length != b_length) {
  129. if (a_length < b_length) {
  130. return(-swap_flag);
  131. }
  133. return(swap_flag);
  134. }
  136. while (a_length > 0 && *a == *b) {
  138. a++; b++; a_length--;
  139. }
  141. if (a_length == 0) {
  143. return(0);
  144. }
  146. if (*a > *b) {
  147. return(swap_flag);
  148. }
  150. return(-swap_flag);
  151.      case DATA_DOUBLE:
  152. d_1 = mach_double_read(a);
  153. d_2 = mach_double_read(b);
  155.        if (d_1 > d_2) {
  156.        return(1);
  157.        } else if (d_2 > d_1) {
  158.        return(-1);
  159.        }
  161.        return(0);
  163. case DATA_FLOAT:
  164. f_1 = mach_float_read(a);
  165. f_2 = mach_float_read(b);
  167.        if (f_1 > f_2) {
  168.        return(1);
  169.        } else if (f_2 > f_1) {
  170.        return(-1);
  171.        }
  173.        return(0);
  174. case DATA_VARMYSQL:
  175. case DATA_MYSQL:
  176. return(innobase_mysql_cmp(
  177. (int)(type->prtype & ~DATA_NOT_NULL),
  178. a, a_length, b, b_length));
  179. default:
  180. assert(0);
  181. }
  183. return(0);
  184. }
  186. /*****************************************************************
  187. This function is used to compare two data fields for which we know the
  188. data type. */
  190. int
  191. cmp_data_data_slow(
  192. /*===============*/
  193. /* out: 1, 0, -1, if data1 is greater, equal, 
  194. less than data2, respectively */
  195. dtype_t* cur_type,/* in: data type of the fields */
  196. byte* data1, /* in: data field (== a pointer to a memory
  197. buffer) */
  198. ulint len1, /* in: data field length or UNIV_SQL_NULL */
  199. byte* data2, /* in: data field (== a pointer to a memory
  200. buffer) */
  201. ulint len2) /* in: data field length or UNIV_SQL_NULL */
  202. {
  203. ulint data1_byte;
  204. ulint data2_byte;
  205. ulint cur_bytes;
  207. ut_ad(dtype_validate(cur_type));
  209. if (len1 == UNIV_SQL_NULL || len2 == UNIV_SQL_NULL) {
  211. if (len1 == len2) {
  213. return(0);
  214. }
  216. if (len1 == UNIV_SQL_NULL) {
  217. /* We define the SQL null to be the smallest possible
  218. value of a field in the alphabetical order */
  220. return(-1);
  221. }
  223. return(1);
  224. }
  226. if (cur_type->mtype >= DATA_FLOAT) {
  227. return(cmp_whole_field(cur_type, data1, len1, data2, len2));
  228. }
  230. /* Compare then the fields */
  232. cur_bytes = 0;
  234. for (;;) {
  235. if (len1 <= cur_bytes) {
  236. if (len2 <= cur_bytes) {
  238. return(0);
  239. }
  241. data1_byte = dtype_get_pad_char(cur_type);
  243. if (data1_byte == ULINT_UNDEFINED) {
  245. return(-1);
  246. }
  247. } else {
  248. data1_byte = *data1;
  249. }
  251. if (len2 <= cur_bytes) {
  252. data2_byte = dtype_get_pad_char(cur_type);
  254. if (data2_byte == ULINT_UNDEFINED) {
  256. return(1);
  257. }
  258. } else {
  259. data2_byte = *data2;
  260. }
  262. if (data1_byte == data2_byte) {
  263. /* If the bytes are equal, they will remain such even
  264. after the collation transformation below */
  266. goto next_byte;
  267. }
  269. if (cur_type->mtype <= DATA_CHAR) {
  270. data1_byte = dtype_collate(cur_type, data1_byte);
  271. data2_byte = dtype_collate(cur_type, data2_byte);
  272. }
  274. if (data1_byte > data2_byte) {
  276. return(1);
  277. } else if (data1_byte < data2_byte) {
  279. return(-1);
  280. }
  281. next_byte:
  282. /* Next byte */
  283. cur_bytes++;
  284. data1++;
  285. data2++;
  286. }
  288. return(0);
  289. }
  291. /*****************************************************************
  292. This function is used to compare a data tuple to a physical record.
  293. Only dtuple->n_fields_cmp first fields are taken into account for
  294. the the data tuple! If we denote by n = n_fields_cmp, then rec must
  295. have either m >= n fields, or it must differ from dtuple in some of
  296. the m fields rec has. */
  298. int
  299. cmp_dtuple_rec_with_match(
  300. /*======================*/
  301. /* out: 1, 0, -1, if dtuple is greater, equal, 
  302. less than rec, respectively, when only the 
  303. common first fields are compared */
  304. dtuple_t* dtuple, /* in: data tuple */
  305. rec_t* rec, /* in: physical record which differs from
  306. dtuple in some of the common fields, or which
  307. has an equal number or more fields than
  308. dtuple */
  309. ulint*   matched_fields, /* in/out: number of already completely 
  310. matched fields; when function returns,
  311. contains the value for current comparison */
  312. ulint*    matched_bytes) /* in/out: number of already matched 
  313. bytes within the first field not completely
  314. matched; when function returns, contains the
  315. value for current comparison */
  316. {
  317. dtype_t* cur_type; /* pointer to type of the current
  318. field in dtuple */
  319. dfield_t* dtuple_field; /* current field in logical record */
  320. ulint dtuple_f_len; /* the length of the current field 
  321. in the logical record */
  322. byte* dtuple_b_ptr; /* pointer to the current byte in 
  323. logical field data */
  324. ulint dtuple_byte; /* value of current byte to be compared 
  325. in dtuple*/
  326. ulint rec_f_len; /* length of current field in rec */
  327. byte* rec_b_ptr; /* pointer to the current byte in 
  328. rec field */
  329. ulint rec_byte; /* value of current byte to be 
  330. compared in rec */
  331. ulint cur_field; /* current field number */
  332. ulint cur_bytes;  /* number of already matched bytes 
  333. in current field */
  334. int ret = 3333; /* return value */
  336. ut_ad(dtuple && rec && matched_fields && matched_bytes);
  337. ut_ad(dtuple_check_typed(dtuple));
  339. cur_field = *matched_fields;
  340. cur_bytes = *matched_bytes;
  342. ut_ad(cur_field <= dtuple_get_n_fields_cmp(dtuple));
  343. ut_ad(cur_field <= rec_get_n_fields(rec));
  345. /* Match fields in a loop; stop if we run out of fields in dtuple */
  347. while (cur_field < dtuple_get_n_fields_cmp(dtuple)) {
  349. dtuple_field = dtuple_get_nth_field(dtuple, cur_field);
  350. cur_type = dfield_get_type(dtuple_field);
  352. dtuple_f_len = dfield_get_len(dtuple_field);
  354. rec_b_ptr = rec_get_nth_field(rec, cur_field, &rec_f_len);
  356. /* If we have matched yet 0 bytes, it may be that one or
  357. both the fields are SQL null, or the record or dtuple may be
  358. the predefined minimum record */
  360. if (cur_bytes == 0) {
  361. if (cur_field == 0) {
  363. if (rec_get_info_bits(rec)
  364.     & REC_INFO_MIN_REC_FLAG) {
  366. if (dtuple_get_info_bits(dtuple)
  367.          & REC_INFO_MIN_REC_FLAG) {
  369.      ret = 0;
  370.      } else {
  371.      ret = 1;
  372.      }
  374. goto order_resolved;
  375. }
  377. if (dtuple_get_info_bits(dtuple)
  378.     & REC_INFO_MIN_REC_FLAG) {
  379.        ret = -1;
  381. goto order_resolved;
  382. }
  383. }
  385.      if (dtuple_f_len == UNIV_SQL_NULL
  386.             || rec_f_len == UNIV_SQL_NULL) {
  388. if (dtuple_f_len == rec_f_len) {
  390. goto next_field;
  391. }
  393. if (rec_f_len == UNIV_SQL_NULL) {
  394. /* We define the SQL null to be the 
  395. smallest possible value of a field 
  396. in the alphabetical order */
  398. ret = 1;
  399. } else {
  400. ret = -1;
  401. }
  403. goto order_resolved;
  404. }
  405. }
  407. if (cur_type->mtype >= DATA_FLOAT) {
  409. ret = cmp_whole_field(cur_type,
  410. dfield_get_data(dtuple_field), dtuple_f_len,
  411. rec_b_ptr, rec_f_len);
  413. if (ret != 0) {
  414. cur_bytes = 0;
  416. goto order_resolved;
  417. } else {
  418. goto next_field;
  419. }
  420. }
  422. /* Set the pointers at the current byte */
  424. rec_b_ptr = rec_b_ptr + cur_bytes;
  425. dtuple_b_ptr = (byte*)dfield_get_data(dtuple_field) 
  426. + cur_bytes;
  427. /* Compare then the fields */
  429. for (;;) {
  430. if (rec_f_len <= cur_bytes) {
  431. if (dtuple_f_len <= cur_bytes) {
  433. goto next_field;
  434. }
  436. rec_byte = dtype_get_pad_char(cur_type);
  438. if (rec_byte == ULINT_UNDEFINED) {
  439. ret = 1;
  441. goto order_resolved;
  442. }
  443. } else {
  444. rec_byte = *rec_b_ptr;
  445. }
  447. if (dtuple_f_len <= cur_bytes) {
  448. dtuple_byte = dtype_get_pad_char(cur_type);
  450. if (dtuple_byte == ULINT_UNDEFINED) {
  451. ret = -1;
  453. goto order_resolved;
  454. }
  455. } else {
  456. dtuple_byte = *dtuple_b_ptr;
  457. }
  459. if (dtuple_byte == rec_byte) {
  460. /* If the bytes are equal, they will
  461. remain such even after the collation
  462. transformation below */
  464. goto next_byte;
  465. }
  467. if (cur_type->mtype <= DATA_CHAR) {
  468. rec_byte = dtype_collate(cur_type, rec_byte);
  469. dtuple_byte = dtype_collate(cur_type, 
  470. dtuple_byte);
  471. }
  473. if (dtuple_byte > rec_byte) {
  474. ret = 1;
  475. goto order_resolved;
  477. } else if (dtuple_byte < rec_byte) {
  478. ret = -1;
  479. goto order_resolved;
  480. }
  481. next_byte:
  482. /* Next byte */
  483. cur_bytes++;
  484. rec_b_ptr++;
  485. dtuple_b_ptr++;
  486. }
  488. next_field:
  489. cur_field++;
  490. cur_bytes = 0;
  491. }
  493. ut_ad(cur_bytes == 0);
  495. ret = 0; /* If we ran out of fields, dtuple was equal to rec
  496. up to the common fields */
  497. order_resolved:
  498. ut_ad((ret >= - 1) && (ret <= 1));
  499. ut_ad(ret == cmp_debug_dtuple_rec_with_match(dtuple, rec,
  500. matched_fields));
  501. ut_ad(*matched_fields == cur_field); /* In the debug version, the
  502. above cmp_debug_... sets
  503. *matched_fields to a value */
  504. *matched_fields = cur_field;
  505. *matched_bytes = cur_bytes;
  507. return(ret);
  508. }
  510. /******************************************************************
  511. Compares a data tuple to a physical record. */
  513. int
  514. cmp_dtuple_rec(
  515. /*===========*/
  516. /* out: 1, 0, -1, if dtuple is greater, equal, 
  517. less than rec, respectively; see the comments
  518. for cmp_dtuple_rec_with_match */
  519. dtuple_t*  dtuple, /* in: data tuple */
  520. rec_t*    rec) /* in: physical record */
  521. {
  522. ulint matched_fields = 0;
  523. ulint matched_bytes = 0;
  525. return(cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields,
  526. &matched_bytes));
  527. }
  529. /******************************************************************
  530. Checks if a dtuple is a prefix of a record. The last field in dtuple
  531. is allowed to be a prefix of the corresponding field in the record. */
  533. ibool
  534. cmp_dtuple_is_prefix_of_rec(
  535. /*========================*/
  536. /* out: TRUE if prefix */
  537. dtuple_t*  dtuple, /* in: data tuple */
  538. rec_t*    rec) /* in: physical record */
  539. {
  540. ulint n_fields;
  541. ulint matched_fields = 0;
  542. ulint matched_bytes = 0;
  544. n_fields = dtuple_get_n_fields(dtuple);
  546. if (n_fields > rec_get_n_fields(rec)) {
  548. return(FALSE);
  549. }
  551. cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields,
  552. &matched_bytes);
  553. if (matched_fields == n_fields) {
  555. return(TRUE);
  556. }
  558. if (matched_fields == n_fields - 1
  559. && matched_bytes == dfield_get_len(
  560. dtuple_get_nth_field(dtuple, n_fields - 1))) {
  561. return(TRUE);
  562. }
  564. return(FALSE);
  565. }
  567. /******************************************************************
  568. Compares a prefix of a data tuple to a prefix of a physical record for
  569. equality. If there are less fields in rec than parameter n_fields, FALSE
  570. is returned. NOTE that n_fields_cmp of dtuple does not affect this
  571. comparison. */
  573. ibool
  574. cmp_dtuple_rec_prefix_equal(
  575. /*========================*/
  576. /* out: TRUE if equal */
  577. dtuple_t* dtuple, /* in: data tuple */
  578. rec_t* rec, /* in: physical record */
  579. ulint n_fields) /* in: number of fields which should be 
  580. compared; must not exceed the number of 
  581. fields in dtuple */
  582. {
  583. ulint matched_fields = 0;
  584. ulint matched_bytes = 0;
  586. ut_ad(n_fields <= dtuple_get_n_fields(dtuple));
  588. if (rec_get_n_fields(rec) < n_fields) {
  590. return(FALSE);
  591. }
  593. cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields, 
  594. &matched_bytes);
  595. if (matched_fields >= n_fields) {
  597. return(TRUE);
  598. }
  600. return(FALSE);
  601. }
  603. /*****************************************************************
  604. This function is used to compare two physical records. Only the common
  605. first fields are compared. */
  607. int
  608. cmp_rec_rec_with_match(
  609. /*===================*/
  610. /* out: 1, 0 , -1 if rec1 is greater, equal,
  611. less, respectively, than rec2; only the common
  612. first fields are compared */
  613. rec_t* rec1, /* in: physical record */
  614. rec_t* rec2, /* in: physical record */
  615. dict_index_t* index, /* in: data dictionary index */
  616. ulint*   matched_fields, /* in/out: number of already completely 
  617. matched fields; when the function returns,
  618. contains the value the for current
  619. comparison */
  620. ulint*    matched_bytes) /* in/out: number of already matched 
  621. bytes within the first field not completely
  622. matched; when the function returns, contains
  623. the value for the current comparison */
  624. {
  625. dtype_t* cur_type; /* pointer to type struct of the
  626. current field in index */
  627. ulint rec1_n_fields; /* the number of fields in rec */
  628. ulint rec1_f_len; /* length of current field in rec */
  629. byte* rec1_b_ptr; /* pointer to the current byte in rec field */
  630. ulint rec1_byte; /* value of current byte to be compared in
  631. rec */
  632. ulint rec2_n_fields; /* the number of fields in rec */
  633. ulint rec2_f_len; /* length of current field in rec */
  634. byte* rec2_b_ptr; /* pointer to the current byte in rec field */
  635. ulint rec2_byte; /* value of current byte to be compared in
  636. rec */
  637. ulint cur_field; /* current field number */
  638. ulint cur_bytes;  /* number of already matched bytes in current
  639. field */
  640. int ret = 3333; /* return value */
  642. ut_ad(rec1 && rec2 && index);
  644. rec1_n_fields = rec_get_n_fields(rec1);
  645. rec2_n_fields = rec_get_n_fields(rec2);
  647. cur_field = *matched_fields;
  648. cur_bytes = *matched_bytes;
  650. /* Match fields in a loop; stop if we run out of fields in either
  651. record */
  653. while ((cur_field < rec1_n_fields) && (cur_field < rec2_n_fields)) {
  655. if (index->type & DICT_UNIVERSAL) {
  656. cur_type = dtype_binary;
  657. } else {
  658. cur_type = dict_col_get_type(
  659.       dict_field_get_col(
  660. dict_index_get_nth_field(index, cur_field)));
  661. }
  663. rec1_b_ptr = rec_get_nth_field(rec1, cur_field, &rec1_f_len);
  664. rec2_b_ptr = rec_get_nth_field(rec2, cur_field, &rec2_f_len);
  666. if (cur_bytes == 0) {
  667. if (cur_field == 0) {
  668. /* Test if rec is the predefined minimum
  669. record */
  670. if (rec_get_info_bits(rec1)
  671. & REC_INFO_MIN_REC_FLAG) {
  673. if (rec_get_info_bits(rec2) 
  674.     & REC_INFO_MIN_REC_FLAG) {
  675. ret = 0;
  676. } else {
  677. ret = -1;
  678. }
  680. goto order_resolved;
  682. } else if (rec_get_info_bits(rec2) 
  683.    & REC_INFO_MIN_REC_FLAG) {
  685. ret = 1;
  687. goto order_resolved;
  688. }
  689. } 
  691.      if (rec1_f_len == UNIV_SQL_NULL
  692.             || rec2_f_len == UNIV_SQL_NULL) {
  694. if (rec1_f_len == rec2_f_len) {
  696. goto next_field;
  698. } else if (rec2_f_len == UNIV_SQL_NULL) {
  700. /* We define the SQL null to be the 
  701. smallest possible value of a field 
  702. in the alphabetical order */
  704. ret = 1;
  705. } else {
  706. ret = -1;
  707. }
  709. goto order_resolved;
  710. }
  711. }
  713. if (cur_type->mtype >= DATA_FLOAT) {
  714. ret = cmp_whole_field(cur_type,
  715. rec1_b_ptr, rec1_f_len,
  716. rec2_b_ptr, rec2_f_len);
  717. if (ret != 0) {
  718. cur_bytes = 0;
  720. goto order_resolved;
  721. } else {
  722. goto next_field;
  723. }
  724. }
  726. /* Set the pointers at the current byte */
  727. rec1_b_ptr = rec1_b_ptr + cur_bytes;
  728. rec2_b_ptr = rec2_b_ptr + cur_bytes;
  730. /* Compare then the fields */
  731. for (;;) {
  732. if (rec2_f_len <= cur_bytes) {
  734. if (rec1_f_len <= cur_bytes) {
  736. goto next_field;
  737. }
  739. rec2_byte = dtype_get_pad_char(cur_type);
  741. if (rec2_byte == ULINT_UNDEFINED) {
  742. ret = 1;
  744. goto order_resolved;
  745. }
  746. } else {
  747. rec2_byte = *rec2_b_ptr;
  748. }
  750. if (rec1_f_len <= cur_bytes) {
  751. rec1_byte = dtype_get_pad_char(cur_type);
  753. if (rec1_byte == ULINT_UNDEFINED) {
  754. ret = -1;
  756. goto order_resolved;
  757. }
  758. } else {
  759. rec1_byte = *rec1_b_ptr;
  760. }
  762. if (rec1_byte == rec2_byte) {
  763. /* If the bytes are equal, they will remain
  764. such even after the collation transformation 
  765. below */
  767. goto next_byte;
  768. }
  770. if (cur_type->mtype <= DATA_CHAR) {
  771. rec1_byte = dtype_collate(cur_type, rec1_byte);
  772. rec2_byte = dtype_collate(cur_type, rec2_byte);
  773. }
  775. if (rec1_byte < rec2_byte) {
  776. ret = -1;
  777. goto order_resolved;
  778. } else if (rec1_byte > rec2_byte) {
  779. ret = 1;
  780. goto order_resolved;
  781. }
  782. next_byte:
  783. /* Next byte */
  785. cur_bytes++;
  786. rec1_b_ptr++;
  787. rec2_b_ptr++;
  788. }
  790. next_field:
  791. cur_field++;
  792. cur_bytes = 0;
  793. }
  795. ut_ad(cur_bytes == 0);
  797. ret = 0; /* If we ran out of fields, rec1 was equal to rec2 up
  798. to the common fields */
  799. order_resolved:
  801. ut_ad((ret >= - 1) && (ret <= 1));
  803. *matched_fields = cur_field;
  804. *matched_bytes = cur_bytes;
  806. return(ret);
  807. }
  809. /*****************************************************************
  810. Used in debug checking of cmp_dtuple_... .
  811. This function is used to compare a data tuple to a physical record. If
  812. dtuple has n fields then rec must have either m >= n fields, or it must
  813. differ from dtuple in some of the m fields rec has. */
  814. static
  815. int
  816. cmp_debug_dtuple_rec_with_match(
  817. /*============================*/
  818. /* out: 1, 0, -1, if dtuple is greater, equal, 
  819. less than rec, respectively, when only the 
  820. common first fields are compared */
  821. dtuple_t* dtuple, /* in: data tuple */
  822. rec_t* rec, /* in: physical record which differs from
  823. dtuple in some of the common fields, or which
  824. has an equal number or more fields than
  825. dtuple */
  826. ulint*   matched_fields) /* in/out: number of already completely 
  827. matched fields; when function returns,
  828. contains the value for current comparison */
  829. {
  830. dtype_t* cur_type; /* pointer to type of the current
  831. field in dtuple */
  832. dfield_t* dtuple_field; /* current field in logical record */
  833. ulint dtuple_f_len; /* the length of the current field 
  834. in the logical record */
  835. byte* dtuple_f_data; /* pointer to the current logical
  836. field data */
  837. ulint rec_f_len; /* length of current field in rec */
  838. byte* rec_f_data; /* pointer to the current rec field */
  839. int ret = 3333; /* return value */
  840. ulint cur_field; /* current field number */
  842. ut_ad(dtuple && rec && matched_fields);
  843. ut_ad(dtuple_check_typed(dtuple));
  845. ut_ad(*matched_fields <= dtuple_get_n_fields_cmp(dtuple));
  846. ut_ad(*matched_fields <= rec_get_n_fields(rec));
  848. cur_field = *matched_fields;
  850. if (cur_field == 0) {
  851. if (rec_get_info_bits(rec) & REC_INFO_MIN_REC_FLAG) {
  853. if (dtuple_get_info_bits(dtuple)
  854.          & REC_INFO_MIN_REC_FLAG) {
  855. ret = 0;
  856. } else {
  857. ret = 1;
  858. }
  860. goto order_resolved;
  861. }
  863. if (dtuple_get_info_bits(dtuple) & REC_INFO_MIN_REC_FLAG) {
  864.   ret = -1;
  866. goto order_resolved;
  867. }
  868. }
  870. /* Match fields in a loop; stop if we run out of fields in dtuple */
  872. while (cur_field < dtuple_get_n_fields_cmp(dtuple)) {
  874. dtuple_field = dtuple_get_nth_field(dtuple, cur_field);
  876. cur_type = dfield_get_type(dtuple_field);
  878. dtuple_f_data = dfield_get_data(dtuple_field);
  879. dtuple_f_len = dfield_get_len(dtuple_field);
  881. rec_f_data = rec_get_nth_field(rec, cur_field, &rec_f_len);
  883. ret = cmp_data_data(cur_type, dtuple_f_data, dtuple_f_len,
  884. rec_f_data, rec_f_len);
  885. if (ret != 0) {
  886. goto order_resolved;
  887. } 
  889. cur_field++;
  890. }
  892. ret = 0; /* If we ran out of fields, dtuple was equal to rec
  893. up to the common fields */
  894. order_resolved:
  895. ut_ad((ret >= - 1) && (ret <= 1));
  897. *matched_fields = cur_field;
  899. return(ret);
  900. }