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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
rem0cmp.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：26k
源码类别：

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. #include "srv0srv.h"
  17. /* ALPHABETICAL ORDER
  18. ==================
  20. The records are put into alphabetical order in the following
  21. way: let F be the first field where two records disagree.
  22. If there is a character in some position n where the the
  23. records disagree, the order is determined by comparison of
  24. the characters at position n, possibly after
  25. collating transformation. If there is no such character,
  26. but the corresponding fields have different lengths, then
  27. if the data type of the fields is paddable,
  28. shorter field is padded with a padding character. If the
  29. data type is not paddable, longer field is considered greater.
  30. Finally, the SQL null is bigger than any other value.
  32. At the present, the comparison functions return 0 in the case,
  33. where two records disagree only in the way that one 
  34. has more fields than the other. */
  36. #ifdef UNIV_DEBUG
  37. /*****************************************************************
  38. Used in debug checking of cmp_dtuple_... .
  39. This function is used to compare a data tuple to a physical record. If
  40. dtuple has n fields then rec must have either m >= n fields, or it must
  41. differ from dtuple in some of the m fields rec has. */
  42. static
  43. int
  44. cmp_debug_dtuple_rec_with_match(
  45. /*============================*/
  46. /* out: 1, 0, -1, if dtuple is greater, equal, 
  47. less than rec, respectively, when only the 
  48. common first fields are compared */
  49. dtuple_t* dtuple, /* in: data tuple */
  50. rec_t* rec, /* in: physical record which differs from
  51. dtuple in some of the common fields, or which
  52. has an equal number or more fields than
  53. dtuple */
  54. ulint*   matched_fields);/* in/out: number of already
  55. completely  matched fields; when function
  56. returns, contains the value for current
  57. comparison */
  58. #endif /* UNIV_DEBUG */
  59. /*****************************************************************
  60. This function is used to compare two data fields for which the data type
  61. is such that we must use MySQL code to compare them. The prototype here
  62. must be a copy of the the one in ha_innobase.cc! */
  63. extern
  64. int
  65. innobase_mysql_cmp(
  66. /*===============*/
  67. /* out: 1, 0, -1, if a is greater,
  68. equal, less than b, respectively */
  69. int mysql_type, /* in: MySQL type */
  70. uint charset_number, /* in: number of the charset */
  71. unsigned char* a, /* in: data field */
  72. unsigned int a_length, /* in: data field length,
  73. not UNIV_SQL_NULL */
  74. unsigned char* b, /* in: data field */
  75. unsigned int b_length); /* in: data field length,
  76. not UNIV_SQL_NULL */
  78. /*************************************************************************
  79. Transforms the character code so that it is ordered appropriately for the
  80. language. This is only used for the latin1 char set. MySQL does the
  81. comparisons for other char sets. */
  82. UNIV_INLINE
  83. ulint
  84. cmp_collate(
  85. /*========*/
  86. /* out: collation order position */
  87. ulint code) /* in: code of a character stored in database record */
  88. {
  89. return((ulint) srv_latin1_ordering[code]);
  90. }
  92. /*****************************************************************
  93. Returns TRUE if two types are equal for comparison purposes. */
  95. ibool
  96. cmp_types_are_equal(
  97. /*================*/
  98. /* out: TRUE if the types are considered
  99. equal in comparisons */
  100. dtype_t* type1, /* in: type 1 */
  101. dtype_t* type2) /* in: type 2 */
  102. {
  103. if (dtype_is_non_binary_string_type(type1->mtype, type1->prtype)
  104.     && dtype_is_non_binary_string_type(type2->mtype, type2->prtype)) {
  106. /* Both are non-binary string types: they can be compared if
  107. and only if the charset-collation is the same */
  109. if (dtype_get_charset_coll(type1->prtype)
  110. == dtype_get_charset_coll(type2->prtype)) {
  111. return(TRUE);
  112. }
  114. return(FALSE);
  115.         }
  117. if (dtype_is_binary_string_type(type1->mtype, type1->prtype)
  118.     && dtype_is_binary_string_type(type2->mtype, type2->prtype)) {
  120. /* Both are binary string types: they can be compared */
  122. return(TRUE);
  123. }
  125.         if (type1->mtype != type2->mtype) {
  127. return(FALSE);
  128. }
  130.         if (type1->mtype == DATA_INT
  131.     && (type1->prtype & DATA_UNSIGNED)
  132. != (type2->prtype & DATA_UNSIGNED)) {
  134. /* The storage format of an unsigned integer is different
  135. from a signed integer: in a signed integer we OR
  136. 0x8000... to the value of positive integers. */
  138. return(FALSE);
  139. }
  141.         if (type1->mtype == DATA_INT && type1->len != type2->len) {
  143. return(FALSE);
  144. }
  146. return(TRUE);
  147. }
  149. /*****************************************************************
  150. Innobase uses this function to compare two data fields for which the data type
  151. is such that we must compare whole fields or call MySQL to do the comparison */
  152. static
  153. int
  154. cmp_whole_field(
  155. /*============*/
  156. /* out: 1, 0, -1, if a is greater,
  157. equal, less than b, respectively */
  158. dtype_t* type, /* in: data type */
  159. unsigned char* a, /* in: data field */
  160. unsigned int a_length, /* in: data field length,
  161. not UNIV_SQL_NULL */
  162. unsigned char* b, /* in: data field */
  163. unsigned int b_length) /* in: data field length,
  164. not UNIV_SQL_NULL */
  165. {
  166. float f_1;
  167. float f_2;
  168. double d_1;
  169. double d_2;
  170. int swap_flag = 1;
  171. ulint data_type;
  173. data_type = type->mtype;
  175. switch (data_type) {
  177.      case DATA_DECIMAL:
  178. /* Remove preceding spaces */
  179. for (; a_length && *a == ' '; a++, a_length--);
  180. for (; b_length && *b == ' '; b++, b_length--);
  182.        if (*a == '-') {
  183. if (*b != '-') {
  184.    return(-1);
  185.    }
  187. a++; b++;
  188. a_length--;
  189. b_length--;
  191. swap_flag = -1;
  193.        } else if (*b == '-') {
  195. return(1);
  196. }
  198.        while (a_length > 0 && (*a == '+' || *a == '0')) {
  199. a++; a_length--;
  200.        }
  202.        while (b_length > 0 && (*b == '+' || *b == '0')) {
  203. b++; b_length--;
  204.        }
  205.       
  206.        if (a_length != b_length) {
  207. if (a_length < b_length) {
  208. return(-swap_flag);
  209. }
  211. return(swap_flag);
  212. }
  214. while (a_length > 0 && *a == *b) {
  216. a++; b++; a_length--;
  217. }
  219. if (a_length == 0) {
  221. return(0);
  222. }
  224. if (*a > *b) {
  225. return(swap_flag);
  226. }
  228. return(-swap_flag);
  229.      case DATA_DOUBLE:
  230. d_1 = mach_double_read(a);
  231. d_2 = mach_double_read(b);
  233.        if (d_1 > d_2) {
  234.        return(1);
  235.        } else if (d_2 > d_1) {
  236.        return(-1);
  237.        }
  239.        return(0);
  241. case DATA_FLOAT:
  242. f_1 = mach_float_read(a);
  243. f_2 = mach_float_read(b);
  245.        if (f_1 > f_2) {
  246.        return(1);
  247.        } else if (f_2 > f_1) {
  248.        return(-1);
  249.        }
  251.        return(0);
  252. case DATA_VARMYSQL:
  253. case DATA_MYSQL:
  254. case DATA_BLOB:
  255. if (data_type == DATA_BLOB
  256.     && 0 != (type->prtype & DATA_BINARY_TYPE)) {
  258. ut_print_timestamp(stderr);
  259.         fprintf(stderr,
  260. "  InnoDB: Error: comparing a binary BLOB with a character set sensitiven"
  261. "InnoDB: comparison!n");
  262. }    
  264. return(innobase_mysql_cmp(
  265. (int)(type->prtype & DATA_MYSQL_TYPE_MASK),
  266. (uint)dtype_get_charset_coll(type->prtype),
  267. a, a_length, b, b_length));
  268. default:
  269.         fprintf(stderr,
  270. "InnoDB: unknown type number %lun",
  271. (ulong) data_type);
  272.         ut_error;
  273. }
  275. return(0);
  276. }
  278. /*****************************************************************
  279. This function is used to compare two data fields for which we know the
  280. data type. */
  282. int
  283. cmp_data_data_slow(
  284. /*===============*/
  285. /* out: 1, 0, -1, if data1 is greater, equal, 
  286. less than data2, respectively */
  287. dtype_t* cur_type,/* in: data type of the fields */
  288. byte* data1, /* in: data field (== a pointer to a memory
  289. buffer) */
  290. ulint len1, /* in: data field length or UNIV_SQL_NULL */
  291. byte* data2, /* in: data field (== a pointer to a memory
  292. buffer) */
  293. ulint len2) /* in: data field length or UNIV_SQL_NULL */
  294. {
  295. ulint data1_byte;
  296. ulint data2_byte;
  297. ulint cur_bytes;
  299. ut_ad(dtype_validate(cur_type));
  301. if (len1 == UNIV_SQL_NULL || len2 == UNIV_SQL_NULL) {
  303. if (len1 == len2) {
  305. return(0);
  306. }
  308. if (len1 == UNIV_SQL_NULL) {
  309. /* We define the SQL null to be the smallest possible
  310. value of a field in the alphabetical order */
  312. return(-1);
  313. }
  315. return(1);
  316. }
  318. if (cur_type->mtype >= DATA_FLOAT
  319.     || (cur_type->mtype == DATA_BLOB
  320.         && 0 == (cur_type->prtype & DATA_BINARY_TYPE)
  321. && dtype_get_charset_coll(cur_type->prtype) !=
  322. data_mysql_latin1_swedish_charset_coll)) {
  324. return(cmp_whole_field(cur_type,
  325. data1, (unsigned) len1,
  326. data2, (unsigned) len2));
  327. }
  329. /* Compare then the fields */
  331. cur_bytes = 0;
  333. for (;;) {
  334. if (len1 <= cur_bytes) {
  335. if (len2 <= cur_bytes) {
  337. return(0);
  338. }
  340. data1_byte = dtype_get_pad_char(cur_type);
  342. if (data1_byte == ULINT_UNDEFINED) {
  344. return(-1);
  345. }
  346. } else {
  347. data1_byte = *data1;
  348. }
  350. if (len2 <= cur_bytes) {
  351. data2_byte = dtype_get_pad_char(cur_type);
  353. if (data2_byte == ULINT_UNDEFINED) {
  355. return(1);
  356. }
  357. } else {
  358. data2_byte = *data2;
  359. }
  361. if (data1_byte == data2_byte) {
  362. /* If the bytes are equal, they will remain such even
  363. after the collation transformation below */
  365. goto next_byte;
  366. }
  368. if (cur_type->mtype <= DATA_CHAR
  369.     || (cur_type->mtype == DATA_BLOB
  370.         && 0 == (cur_type->prtype & DATA_BINARY_TYPE))) {
  372. data1_byte = cmp_collate(data1_byte);
  373. data2_byte = cmp_collate(data2_byte);
  374. }
  376. if (data1_byte > data2_byte) {
  378. return(1);
  379. } else if (data1_byte < data2_byte) {
  381. return(-1);
  382. }
  383. next_byte:
  384. /* Next byte */
  385. cur_bytes++;
  386. data1++;
  387. data2++;
  388. }
  390. return(0); /* Not reached */
  391. }
  393. /*****************************************************************
  394. This function is used to compare a data tuple to a physical record.
  395. Only dtuple->n_fields_cmp first fields are taken into account for
  396. the the data tuple! If we denote by n = n_fields_cmp, then rec must
  397. have either m >= n fields, or it must differ from dtuple in some of
  398. the m fields rec has. If rec has an externally stored field we do not
  399. compare it but return with value 0 if such a comparison should be
  400. made. */
  402. int
  403. cmp_dtuple_rec_with_match(
  404. /*======================*/
  405. /* out: 1, 0, -1, if dtuple is greater, equal, 
  406. less than rec, respectively, when only the 
  407. common first fields are compared, or
  408. until the first externally stored field in
  409. rec */
  410. dtuple_t* dtuple, /* in: data tuple */
  411. rec_t* rec, /* in: physical record which differs from
  412. dtuple in some of the common fields, or which
  413. has an equal number or more fields than
  414. dtuple */
  415. ulint*   matched_fields, /* in/out: number of already completely 
  416. matched fields; when function returns,
  417. contains the value for current comparison */
  418. ulint*    matched_bytes) /* in/out: number of already matched 
  419. bytes within the first field not completely
  420. matched; when function returns, contains the
  421. value for current comparison */
  422. {
  423. dtype_t* cur_type; /* pointer to type of the current
  424. field in dtuple */
  425. dfield_t* dtuple_field; /* current field in logical record */
  426. ulint dtuple_f_len; /* the length of the current field 
  427. in the logical record */
  428. byte* dtuple_b_ptr; /* pointer to the current byte in 
  429. logical field data */
  430. ulint dtuple_byte; /* value of current byte to be compared 
  431. in dtuple*/
  432. ulint rec_f_len; /* length of current field in rec */
  433. byte* rec_b_ptr; /* pointer to the current byte in 
  434. rec field */
  435. ulint rec_byte; /* value of current byte to be 
  436. compared in rec */
  437. ulint cur_field; /* current field number */
  438. ulint cur_bytes;  /* number of already matched bytes 
  439. in current field */
  440. int ret = 3333; /* return value */
  442. ut_ad(dtuple && rec && matched_fields && matched_bytes);
  443. ut_ad(dtuple_check_typed(dtuple));
  445. cur_field = *matched_fields;
  446. cur_bytes = *matched_bytes;
  448. ut_ad(cur_field <= dtuple_get_n_fields_cmp(dtuple));
  449. ut_ad(cur_field <= rec_get_n_fields(rec));
  451. /* Match fields in a loop; stop if we run out of fields in dtuple
  452. or find an externally stored field */
  454. while (cur_field < dtuple_get_n_fields_cmp(dtuple)) {
  456. dtuple_field = dtuple_get_nth_field(dtuple, cur_field);
  457. cur_type = dfield_get_type(dtuple_field);
  459. dtuple_f_len = dfield_get_len(dtuple_field);
  461. rec_b_ptr = rec_get_nth_field(rec, cur_field, &rec_f_len);
  463. /* If we have matched yet 0 bytes, it may be that one or
  464. both the fields are SQL null, or the record or dtuple may be
  465. the predefined minimum record, or the field is externally
  466. stored */
  468. if (cur_bytes == 0) {
  469. if (cur_field == 0) {
  471. if (rec_get_info_bits(rec)
  472.     & REC_INFO_MIN_REC_FLAG) {
  474. if (dtuple_get_info_bits(dtuple)
  475.          & REC_INFO_MIN_REC_FLAG) {
  477.      ret = 0;
  478.      } else {
  479.      ret = 1;
  480.      }
  482. goto order_resolved;
  483. }
  485. if (dtuple_get_info_bits(dtuple)
  486.     & REC_INFO_MIN_REC_FLAG) {
  487.        ret = -1;
  489. goto order_resolved;
  490. }
  491. }
  493. if (rec_get_nth_field_extern_bit(rec, cur_field)) {
  494. /* We do not compare to an externally
  495. stored field */
  497. ret = 0;
  499. goto order_resolved;
  500. }
  502.      if (dtuple_f_len == UNIV_SQL_NULL
  503.             || rec_f_len == UNIV_SQL_NULL) {
  505. if (dtuple_f_len == rec_f_len) {
  507. goto next_field;
  508. }
  510. if (rec_f_len == UNIV_SQL_NULL) {
  511. /* We define the SQL null to be the 
  512. smallest possible value of a field 
  513. in the alphabetical order */
  515. ret = 1;
  516. } else {
  517. ret = -1;
  518. }
  520. goto order_resolved;
  521. }
  522. }
  524. if (cur_type->mtype >= DATA_FLOAT
  525.          || (cur_type->mtype == DATA_BLOB
  526.          && 0 == (cur_type->prtype & DATA_BINARY_TYPE)
  527. && dtype_get_charset_coll(cur_type->prtype) !=
  528. data_mysql_latin1_swedish_charset_coll)) {
  530. ret = cmp_whole_field(
  531. cur_type,
  532. dfield_get_data(dtuple_field),
  533. (unsigned) dtuple_f_len,
  534. rec_b_ptr, (unsigned) rec_f_len);
  536. if (ret != 0) {
  537. cur_bytes = 0;
  539. goto order_resolved;
  540. } else {
  541. goto next_field;
  542. }
  543. }
  545. /* Set the pointers at the current byte */
  547. rec_b_ptr = rec_b_ptr + cur_bytes;
  548. dtuple_b_ptr = (byte*)dfield_get_data(dtuple_field) 
  549. + cur_bytes;
  550. /* Compare then the fields */
  552. for (;;) {
  553. if (rec_f_len <= cur_bytes) {
  554. if (dtuple_f_len <= cur_bytes) {
  556. goto next_field;
  557. }
  559. rec_byte = dtype_get_pad_char(cur_type);
  561. if (rec_byte == ULINT_UNDEFINED) {
  562. ret = 1;
  564. goto order_resolved;
  565. }
  566. } else {
  567. rec_byte = *rec_b_ptr;
  568. }
  570. if (dtuple_f_len <= cur_bytes) {
  571. dtuple_byte = dtype_get_pad_char(cur_type);
  573. if (dtuple_byte == ULINT_UNDEFINED) {
  574. ret = -1;
  576. goto order_resolved;
  577. }
  578. } else {
  579. dtuple_byte = *dtuple_b_ptr;
  580. }
  582. if (dtuple_byte == rec_byte) {
  583. /* If the bytes are equal, they will
  584. remain such even after the collation
  585. transformation below */
  587. goto next_byte;
  588. }
  590. if (cur_type->mtype <= DATA_CHAR
  591.     || (cur_type->mtype == DATA_BLOB
  592.         && 0 ==
  593.     (cur_type->prtype & DATA_BINARY_TYPE))) {
  595. rec_byte = cmp_collate(rec_byte);
  596. dtuple_byte = cmp_collate(dtuple_byte);
  597. }
  599. if (dtuple_byte > rec_byte) {
  600. ret = 1;
  601. goto order_resolved;
  603. } else if (dtuple_byte < rec_byte) {
  604. ret = -1;
  605. goto order_resolved;
  606. }
  607. next_byte:
  608. /* Next byte */
  609. cur_bytes++;
  610. rec_b_ptr++;
  611. dtuple_b_ptr++;
  612. }
  614. next_field:
  615. cur_field++;
  616. cur_bytes = 0;
  617. }
  619. ut_ad(cur_bytes == 0);
  621. ret = 0; /* If we ran out of fields, dtuple was equal to rec
  622. up to the common fields */
  623. order_resolved:
  624. ut_ad((ret >= - 1) && (ret <= 1));
  625. ut_ad(ret == cmp_debug_dtuple_rec_with_match(dtuple, rec,
  626. matched_fields));
  627. ut_ad(*matched_fields == cur_field); /* In the debug version, the
  628. above cmp_debug_... sets
  629. *matched_fields to a value */
  630. *matched_fields = cur_field;
  631. *matched_bytes = cur_bytes;
  633. return(ret);
  634. }
  636. /******************************************************************
  637. Compares a data tuple to a physical record. */
  639. int
  640. cmp_dtuple_rec(
  641. /*===========*/
  642. /* out: 1, 0, -1, if dtuple is greater, equal, 
  643. less than rec, respectively; see the comments
  644. for cmp_dtuple_rec_with_match */
  645. dtuple_t*  dtuple, /* in: data tuple */
  646. rec_t*    rec) /* in: physical record */
  647. {
  648. ulint matched_fields = 0;
  649. ulint matched_bytes = 0;
  651. return(cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields,
  652. &matched_bytes));
  653. }
  655. /******************************************************************
  656. Checks if a dtuple is a prefix of a record. The last field in dtuple
  657. is allowed to be a prefix of the corresponding field in the record. */
  659. ibool
  660. cmp_dtuple_is_prefix_of_rec(
  661. /*========================*/
  662. /* out: TRUE if prefix */
  663. dtuple_t*  dtuple, /* in: data tuple */
  664. rec_t*    rec) /* in: physical record */
  665. {
  666. ulint n_fields;
  667. ulint matched_fields = 0;
  668. ulint matched_bytes = 0;
  670. n_fields = dtuple_get_n_fields(dtuple);
  672. if (n_fields > rec_get_n_fields(rec)) {
  674. return(FALSE);
  675. }
  677. cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields,
  678. &matched_bytes);
  679. if (matched_fields == n_fields) {
  681. return(TRUE);
  682. }
  684. if (matched_fields == n_fields - 1
  685. && matched_bytes == dfield_get_len(
  686. dtuple_get_nth_field(dtuple, n_fields - 1))) {
  687. return(TRUE);
  688. }
  690. return(FALSE);
  691. }
  693. /******************************************************************
  694. Compares a prefix of a data tuple to a prefix of a physical record for
  695. equality. If there are less fields in rec than parameter n_fields, FALSE
  696. is returned. NOTE that n_fields_cmp of dtuple does not affect this
  697. comparison. */
  699. ibool
  700. cmp_dtuple_rec_prefix_equal(
  701. /*========================*/
  702. /* out: TRUE if equal */
  703. dtuple_t* dtuple, /* in: data tuple */
  704. rec_t* rec, /* in: physical record */
  705. ulint n_fields) /* in: number of fields which should be 
  706. compared; must not exceed the number of 
  707. fields in dtuple */
  708. {
  709. ulint matched_fields = 0;
  710. ulint matched_bytes = 0;
  712. ut_ad(n_fields <= dtuple_get_n_fields(dtuple));
  714. if (rec_get_n_fields(rec) < n_fields) {
  716. return(FALSE);
  717. }
  719. cmp_dtuple_rec_with_match(dtuple, rec, &matched_fields, 
  720. &matched_bytes);
  721. if (matched_fields >= n_fields) {
  723. return(TRUE);
  724. }
  726. return(FALSE);
  727. }
  729. /*****************************************************************
  730. This function is used to compare two physical records. Only the common
  731. first fields are compared, and if an externally stored field is
  732. encountered, then 0 is returned. */
  734. int
  735. cmp_rec_rec_with_match(
  736. /*===================*/
  737. /* out: 1, 0 , -1 if rec1 is greater, equal,
  738. less, respectively, than rec2; only the common
  739. first fields are compared */
  740. rec_t* rec1, /* in: physical record */
  741. rec_t* rec2, /* in: physical record */
  742. dict_index_t* index, /* in: data dictionary index */
  743. ulint*   matched_fields, /* in/out: number of already completely 
  744. matched fields; when the function returns,
  745. contains the value the for current
  746. comparison */
  747. ulint*    matched_bytes) /* in/out: number of already matched 
  748. bytes within the first field not completely
  749. matched; when the function returns, contains
  750. the value for the current comparison */
  751. {
  752. dtype_t* cur_type; /* pointer to type struct of the
  753. current field in index */
  754. ulint rec1_n_fields; /* the number of fields in rec */
  755. ulint rec1_f_len; /* length of current field in rec */
  756. byte* rec1_b_ptr; /* pointer to the current byte in rec field */
  757. ulint rec1_byte; /* value of current byte to be compared in
  758. rec */
  759. ulint rec2_n_fields; /* the number of fields in rec */
  760. ulint rec2_f_len; /* length of current field in rec */
  761. byte* rec2_b_ptr; /* pointer to the current byte in rec field */
  762. ulint rec2_byte; /* value of current byte to be compared in
  763. rec */
  764. ulint cur_field; /* current field number */
  765. ulint cur_bytes;  /* number of already matched bytes in current
  766. field */
  767. int ret = 3333; /* return value */
  769. ut_ad(rec1 && rec2 && index);
  771. rec1_n_fields = rec_get_n_fields(rec1);
  772. rec2_n_fields = rec_get_n_fields(rec2);
  774. cur_field = *matched_fields;
  775. cur_bytes = *matched_bytes;
  777. /* Match fields in a loop; stop if we run out of fields in either
  778. record */
  780. while ((cur_field < rec1_n_fields) && (cur_field < rec2_n_fields)) {
  782. if (index->type & DICT_UNIVERSAL) {
  783. cur_type = dtype_binary;
  784. } else {
  785. cur_type = dict_col_get_type(
  786.       dict_field_get_col(
  787. dict_index_get_nth_field(index, cur_field)));
  788. }
  790. rec1_b_ptr = rec_get_nth_field(rec1, cur_field, &rec1_f_len);
  791. rec2_b_ptr = rec_get_nth_field(rec2, cur_field, &rec2_f_len);
  793. if (cur_bytes == 0) {
  794. if (cur_field == 0) {
  795. /* Test if rec is the predefined minimum
  796. record */
  797. if (rec_get_info_bits(rec1)
  798. & REC_INFO_MIN_REC_FLAG) {
  800. if (rec_get_info_bits(rec2) 
  801.     & REC_INFO_MIN_REC_FLAG) {
  802. ret = 0;
  803. } else {
  804. ret = -1;
  805. }
  807. goto order_resolved;
  809. } else if (rec_get_info_bits(rec2) 
  810.    & REC_INFO_MIN_REC_FLAG) {
  812. ret = 1;
  814. goto order_resolved;
  815. }
  816. }
  818. if (rec_get_nth_field_extern_bit(rec1, cur_field)
  819.     || rec_get_nth_field_extern_bit(rec2, cur_field)) {
  820. /* We do not compare to an externally
  821. stored field */
  823. ret = 0;
  825. goto order_resolved;
  826. }
  828.      if (rec1_f_len == UNIV_SQL_NULL
  829.             || rec2_f_len == UNIV_SQL_NULL) {
  831. if (rec1_f_len == rec2_f_len) {
  833. goto next_field;
  835. } else if (rec2_f_len == UNIV_SQL_NULL) {
  837. /* We define the SQL null to be the 
  838. smallest possible value of a field 
  839. in the alphabetical order */
  841. ret = 1;
  842. } else {
  843. ret = -1;
  844. }
  846. goto order_resolved;
  847. }
  848. }
  850. if (cur_type->mtype >= DATA_FLOAT
  851.          || (cur_type->mtype == DATA_BLOB
  852.          && 0 == (cur_type->prtype & DATA_BINARY_TYPE)
  853. && dtype_get_charset_coll(cur_type->prtype) !=
  854. data_mysql_latin1_swedish_charset_coll)) {
  856. ret = cmp_whole_field(cur_type,
  857. rec1_b_ptr, (unsigned) rec1_f_len,
  858. rec2_b_ptr, (unsigned) rec2_f_len);
  859. if (ret != 0) {
  860. cur_bytes = 0;
  862. goto order_resolved;
  863. } else {
  864. goto next_field;
  865. }
  866. }
  868. /* Set the pointers at the current byte */
  869. rec1_b_ptr = rec1_b_ptr + cur_bytes;
  870. rec2_b_ptr = rec2_b_ptr + cur_bytes;
  872. /* Compare then the fields */
  873. for (;;) {
  874. if (rec2_f_len <= cur_bytes) {
  876. if (rec1_f_len <= cur_bytes) {
  878. goto next_field;
  879. }
  881. rec2_byte = dtype_get_pad_char(cur_type);
  883. if (rec2_byte == ULINT_UNDEFINED) {
  884. ret = 1;
  886. goto order_resolved;
  887. }
  888. } else {
  889. rec2_byte = *rec2_b_ptr;
  890. }
  892. if (rec1_f_len <= cur_bytes) {
  893. rec1_byte = dtype_get_pad_char(cur_type);
  895. if (rec1_byte == ULINT_UNDEFINED) {
  896. ret = -1;
  898. goto order_resolved;
  899. }
  900. } else {
  901. rec1_byte = *rec1_b_ptr;
  902. }
  904. if (rec1_byte == rec2_byte) {
  905. /* If the bytes are equal, they will remain
  906. such even after the collation transformation 
  907. below */
  909. goto next_byte;
  910. }
  912. if (cur_type->mtype <= DATA_CHAR
  913.     || (cur_type->mtype == DATA_BLOB
  914.         && 0 ==
  915.     (cur_type->prtype & DATA_BINARY_TYPE))) {
  917. rec1_byte = cmp_collate(rec1_byte);
  918. rec2_byte = cmp_collate(rec2_byte);
  919. }
  921. if (rec1_byte < rec2_byte) {
  922. ret = -1;
  923. goto order_resolved;
  924. } else if (rec1_byte > rec2_byte) {
  925. ret = 1;
  926. goto order_resolved;
  927. }
  928. next_byte:
  929. /* Next byte */
  931. cur_bytes++;
  932. rec1_b_ptr++;
  933. rec2_b_ptr++;
  934. }
  936. next_field:
  937. cur_field++;
  938. cur_bytes = 0;
  939. }
  941. ut_ad(cur_bytes == 0);
  943. ret = 0; /* If we ran out of fields, rec1 was equal to rec2 up
  944. to the common fields */
  945. order_resolved:
  947. ut_ad((ret >= - 1) && (ret <= 1));
  949. *matched_fields = cur_field;
  950. *matched_bytes = cur_bytes;
  952. return(ret);
  953. }
  955. #ifdef UNIV_DEBUG
  956. /*****************************************************************
  957. Used in debug checking of cmp_dtuple_... .
  958. This function is used to compare a data tuple to a physical record. If
  959. dtuple has n fields then rec must have either m >= n fields, or it must
  960. differ from dtuple in some of the m fields rec has. If encounters an
  961. externally stored field, returns 0. */
  962. static
  963. int
  964. cmp_debug_dtuple_rec_with_match(
  965. /*============================*/
  966. /* out: 1, 0, -1, if dtuple is greater, equal, 
  967. less than rec, respectively, when only the 
  968. common first fields are compared */
  969. dtuple_t* dtuple, /* in: data tuple */
  970. rec_t* rec, /* in: physical record which differs from
  971. dtuple in some of the common fields, or which
  972. has an equal number or more fields than
  973. dtuple */
  974. ulint*   matched_fields) /* in/out: number of already
  975. completely matched fields; when function
  976. returns, contains the value for current
  977. comparison */
  978. {
  979. dtype_t* cur_type; /* pointer to type of the current
  980. field in dtuple */
  981. dfield_t* dtuple_field; /* current field in logical record */
  982. ulint dtuple_f_len; /* the length of the current field 
  983. in the logical record */
  984. byte* dtuple_f_data; /* pointer to the current logical
  985. field data */
  986. ulint rec_f_len; /* length of current field in rec */
  987. byte* rec_f_data; /* pointer to the current rec field */
  988. int ret = 3333; /* return value */
  989. ulint cur_field; /* current field number */
  991. ut_ad(dtuple && rec && matched_fields);
  992. ut_ad(dtuple_check_typed(dtuple));
  994. ut_ad(*matched_fields <= dtuple_get_n_fields_cmp(dtuple));
  995. ut_ad(*matched_fields <= rec_get_n_fields(rec));
  997. cur_field = *matched_fields;
  999. if (cur_field == 0) {
  1000. if (rec_get_info_bits(rec) & REC_INFO_MIN_REC_FLAG) {
  1002. if (dtuple_get_info_bits(dtuple)
  1003.          & REC_INFO_MIN_REC_FLAG) {
  1004. ret = 0;
  1005. } else {
  1006. ret = 1;
  1007. }
  1009. goto order_resolved;
  1010. }
  1012. if (dtuple_get_info_bits(dtuple) & REC_INFO_MIN_REC_FLAG) {
  1013.   ret = -1;
  1015. goto order_resolved;
  1016. }
  1017. }
  1019. /* Match fields in a loop; stop if we run out of fields in dtuple */
  1021. while (cur_field < dtuple_get_n_fields_cmp(dtuple)) {
  1023. dtuple_field = dtuple_get_nth_field(dtuple, cur_field);
  1025. cur_type = dfield_get_type(dtuple_field);
  1027. dtuple_f_data = dfield_get_data(dtuple_field);
  1028. dtuple_f_len = dfield_get_len(dtuple_field);
  1030. rec_f_data = rec_get_nth_field(rec, cur_field, &rec_f_len);
  1032. if (rec_get_nth_field_extern_bit(rec, cur_field)) {
  1033. /* We do not compare to an externally stored field */
  1035. ret = 0;
  1037. goto order_resolved;
  1038. }
  1040. ret = cmp_data_data(cur_type, dtuple_f_data, dtuple_f_len,
  1041. rec_f_data, rec_f_len);
  1042. if (ret != 0) {
  1043. goto order_resolved;
  1044. } 
  1046. cur_field++;
  1047. }
  1049. ret = 0; /* If we ran out of fields, dtuple was equal to rec
  1050. up to the common fields */
  1051. order_resolved:
  1052. ut_ad((ret >= - 1) && (ret <= 1));
  1054. *matched_fields = cur_field;
  1056. return(ret);
  1057. }
  1058. #endif /* UNIV_DEBUG */