← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/cmpfunc.cc

  • Committer: Brian Aker
  • Date: 2009-12-18 18:31:01 UTC
  • mfrom: (1241.2.7 build)
  • Revision ID: brian@gaz-20091218183101-igqg1dtowpa0o70s
Fixed from Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/**
21
21
  This file defines all compare functions
22
22
*/
23
23
 
24
 
#include "config.h"
 
24
#include "drizzled/server_includes.h"
25
25
#include "drizzled/sql_select.h"
26
26
#include "drizzled/error.h"
27
27
#include "drizzled/temporal.h"
31
31
#include "drizzled/item/int_with_ref.h"
32
32
#include "drizzled/check_stack_overrun.h"
33
33
#include "drizzled/time_functions.h"
34
 
#include "drizzled/internal/my_sys.h"
35
 
#include <math.h>
 
34
 
36
35
#include <algorithm>
37
36
 
38
37
using namespace std;
39
38
 
40
 
namespace drizzled
41
 
{
42
 
 
43
 
extern const double log_10[309];
44
39
 
45
40
static Eq_creator eq_creator;
46
41
static Ne_creator ne_creator;
463
458
      the call to save_in_field below overrides that value.
464
459
    */
465
460
    if (field_item->depended_from)
466
 
    {
467
461
      orig_field_val= field->val_int();
468
 
    }
469
 
 
470
462
    if (!(*item)->is_null() && !(*item)->save_in_field(field, 1))
471
463
    {
472
464
      Item *tmp= new Item_int_with_ref(field->val_int(), *item,
475
467
        session->change_item_tree(item, tmp);
476
468
      result= 1;                                        // Item was replaced
477
469
    }
478
 
 
479
470
    /* Restore the original field value. */
480
471
    if (field_item->depended_from)
481
472
    {
482
 
      result= field->store(orig_field_val, field->isUnsigned());
 
473
      result= field->store(orig_field_val, true);
483
474
      /* orig_field_val must be a valid value that can be restored back. */
484
475
      assert(!result);
485
476
    }
493
484
void Item_bool_func2::fix_length_and_dec()
494
485
{
495
486
  max_length= 1;                                     // Function returns 0 or 1
 
487
  Session *session;
496
488
 
497
489
  /*
498
490
    As some compare functions are generated after sql_yacc,
530
522
    return;
531
523
  }
532
524
 
 
525
  session= current_session;
533
526
  Item_field *field_item= NULL;
534
527
 
535
528
  if (args[0]->real_item()->type() == FIELD_ITEM)
538
531
    if (field_item->field->can_be_compared_as_int64_t() &&
539
532
        !(field_item->is_datetime() && args[1]->result_type() == STRING_RESULT))
540
533
    {
541
 
      if (convert_constant_item(&getSession(), field_item, &args[1]))
 
534
      if (convert_constant_item(session, field_item, &args[1]))
542
535
      {
543
536
        cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
544
537
                         INT_RESULT);           // Works for all types.
554
547
          !(field_item->is_datetime() &&
555
548
            args[0]->result_type() == STRING_RESULT))
556
549
      {
557
 
        if (convert_constant_item(&getSession(), field_item, &args[0]))
 
550
        if (convert_constant_item(session, field_item, &args[0]))
558
551
        {
559
552
          cmp.set_cmp_func(this, tmp_arg, tmp_arg+1,
560
553
                           INT_RESULT); // Works for all types.
572
565
{
573
566
  owner= item;
574
567
  func= comparator_matrix[type]
575
 
    [test(owner->functype() == Item_func::EQUAL_FUNC)];
576
 
 
 
568
                         [test(owner->functype() == Item_func::EQUAL_FUNC)];
577
569
  switch (type) {
578
570
  case ROW_RESULT:
579
 
    {
580
 
      uint32_t n= (*a)->cols();
581
 
      if (n != (*b)->cols())
582
 
      {
583
 
        my_error(ER_OPERAND_COLUMNS, MYF(0), n);
584
 
        comparators= 0;
585
 
        return 1;
586
 
      }
587
 
      if (!(comparators= new Arg_comparator[n]))
588
 
        return 1;
589
 
      for (uint32_t i=0; i < n; i++)
590
 
      {
591
 
        if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
592
 
        {
593
 
          my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->element_index(i)->cols());
594
 
          return 1;
595
 
        }
596
 
        comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
597
 
      }
598
 
      break;
599
 
    }
600
 
 
 
571
  {
 
572
    uint32_t n= (*a)->cols();
 
573
    if (n != (*b)->cols())
 
574
    {
 
575
      my_error(ER_OPERAND_COLUMNS, MYF(0), n);
 
576
      comparators= 0;
 
577
      return 1;
 
578
    }
 
579
    if (!(comparators= new Arg_comparator[n]))
 
580
      return 1;
 
581
    for (uint32_t i=0; i < n; i++)
 
582
    {
 
583
      if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
 
584
      {
 
585
        my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->element_index(i)->cols());
 
586
        return 1;
 
587
      }
 
588
      comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
 
589
    }
 
590
    break;
 
591
  }
601
592
  case STRING_RESULT:
 
593
  {
 
594
    /*
 
595
      We must set cmp_charset here as we may be called from for an automatic
 
596
      generated item, like in natural join
 
597
    */
 
598
    if (cmp_collation.set((*a)->collation, (*b)->collation) ||
 
599
        cmp_collation.derivation == DERIVATION_NONE)
 
600
    {
 
601
      my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
 
602
      return 1;
 
603
    }
 
604
    if (cmp_collation.collation == &my_charset_bin)
602
605
    {
603
606
      /*
604
 
        We must set cmp_charset here as we may be called from for an automatic
605
 
        generated item, like in natural join
 
607
        We are using BLOB/BINARY/VARBINARY, change to compare byte by byte,
 
608
        without removing end space
606
609
      */
607
 
      if (cmp_collation.set((*a)->collation, (*b)->collation) ||
608
 
          cmp_collation.derivation == DERIVATION_NONE)
609
 
      {
610
 
        my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
611
 
        return 1;
612
 
      }
613
 
      if (cmp_collation.collation == &my_charset_bin)
614
 
      {
615
 
        /*
616
 
          We are using BLOB/BINARY/VARBINARY, change to compare byte by byte,
617
 
          without removing end space
618
 
        */
619
 
        if (func == &Arg_comparator::compare_string)
620
 
          func= &Arg_comparator::compare_binary_string;
621
 
        else if (func == &Arg_comparator::compare_e_string)
622
 
          func= &Arg_comparator::compare_e_binary_string;
 
610
      if (func == &Arg_comparator::compare_string)
 
611
        func= &Arg_comparator::compare_binary_string;
 
612
      else if (func == &Arg_comparator::compare_e_string)
 
613
        func= &Arg_comparator::compare_e_binary_string;
623
614
 
624
 
        /*
625
 
          As this is binary compassion, mark all fields that they can't be
626
 
          transformed. Otherwise we would get into trouble with comparisons
627
 
like:
628
 
WHERE col= 'j' AND col LIKE BINARY 'j'
629
 
which would be transformed to:
630
 
WHERE col= 'j'
 
615
      /*
 
616
        As this is binary compassion, mark all fields that they can't be
 
617
        transformed. Otherwise we would get into trouble with comparisons
 
618
        like:
 
619
        WHERE col= 'j' AND col LIKE BINARY 'j'
 
620
        which would be transformed to:
 
621
        WHERE col= 'j'
631
622
      */
632
 
        (*a)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
633
 
        (*b)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
634
 
      }
635
 
      break;
 
623
      (*a)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
 
624
      (*b)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
636
625
    }
 
626
    break;
 
627
  }
637
628
  case INT_RESULT:
638
 
    {
639
 
      if (func == &Arg_comparator::compare_int_signed)
640
 
      {
641
 
        if ((*a)->unsigned_flag)
642
 
          func= (((*b)->unsigned_flag)?
643
 
                 &Arg_comparator::compare_int_unsigned :
644
 
                 &Arg_comparator::compare_int_unsigned_signed);
645
 
        else if ((*b)->unsigned_flag)
646
 
          func= &Arg_comparator::compare_int_signed_unsigned;
647
 
      }
648
 
      else if (func== &Arg_comparator::compare_e_int)
649
 
      {
650
 
        if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
651
 
          func= &Arg_comparator::compare_e_int_diff_signedness;
652
 
      }
653
 
      break;
654
 
    }
 
629
  {
 
630
    if (func == &Arg_comparator::compare_int_signed)
 
631
    {
 
632
      if ((*a)->unsigned_flag)
 
633
        func= (((*b)->unsigned_flag)?
 
634
               &Arg_comparator::compare_int_unsigned :
 
635
               &Arg_comparator::compare_int_unsigned_signed);
 
636
      else if ((*b)->unsigned_flag)
 
637
        func= &Arg_comparator::compare_int_signed_unsigned;
 
638
    }
 
639
    else if (func== &Arg_comparator::compare_e_int)
 
640
    {
 
641
      if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
 
642
        func= &Arg_comparator::compare_e_int_diff_signedness;
 
643
    }
 
644
    break;
 
645
  }
655
646
  case DECIMAL_RESULT:
656
647
    break;
657
648
  case REAL_RESULT:
 
649
  {
 
650
    if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
658
651
    {
659
 
      if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
660
 
      {
661
 
        precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
662
 
        if (func == &Arg_comparator::compare_real)
663
 
          func= &Arg_comparator::compare_real_fixed;
664
 
        else if (func == &Arg_comparator::compare_e_real)
665
 
          func= &Arg_comparator::compare_e_real_fixed;
666
 
      }
667
 
      break;
 
652
      precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
 
653
      if (func == &Arg_comparator::compare_real)
 
654
        func= &Arg_comparator::compare_real_fixed;
 
655
      else if (func == &Arg_comparator::compare_e_real)
 
656
        func= &Arg_comparator::compare_e_real_fixed;
668
657
    }
669
 
  }
670
 
 
 
658
    break;
 
659
  }
 
660
  default:
 
661
    assert(0);
 
662
  }
671
663
  return 0;
672
664
}
673
665
 
694
686
    converted value. 0 on error and on zero-dates -- check 'failure'
695
687
*/
696
688
 
697
 
static int64_t
698
 
get_date_from_str(Session *session, String *str, type::timestamp_t warn_type,
 
689
static uint64_t
 
690
get_date_from_str(Session *session, String *str, enum enum_drizzle_timestamp_type warn_type,
699
691
                  char *warn_name, bool *error_arg)
700
692
{
701
 
  int64_t value= 0;
702
 
  type::cut_t error= type::VALID;
703
 
  type::Time l_time;
704
 
  type::timestamp_t ret;
705
 
 
706
 
  ret= l_time.store(str->ptr(), str->length(),
707
 
                    (TIME_FUZZY_DATE | MODE_INVALID_DATES | (session->variables.sql_mode & MODE_NO_ZERO_DATE)),
708
 
                    error);
709
 
 
710
 
  if (ret == type::DRIZZLE_TIMESTAMP_DATETIME || ret == type::DRIZZLE_TIMESTAMP_DATE)
 
693
  uint64_t value= 0;
 
694
  int error;
 
695
  DRIZZLE_TIME l_time;
 
696
  enum enum_drizzle_timestamp_type ret;
 
697
 
 
698
  ret= str_to_datetime(str->ptr(), str->length(), &l_time,
 
699
                       (TIME_FUZZY_DATE | MODE_INVALID_DATES |
 
700
                        (session->variables.sql_mode & MODE_NO_ZERO_DATE)),
 
701
                       &error);
 
702
 
 
703
  if (ret == DRIZZLE_TIMESTAMP_DATETIME || ret == DRIZZLE_TIMESTAMP_DATE)
711
704
  {
712
705
    /*
713
706
      Do not return yet, we may still want to throw a "trailing garbage"
714
707
      warning.
715
708
    */
716
709
    *error_arg= false;
717
 
    l_time.convert(value);
 
710
    value= TIME_to_uint64_t_datetime(&l_time);
718
711
  }
719
712
  else
720
713
  {
721
714
    *error_arg= true;
722
 
    error= type::CUT;                                   /* force warning */
 
715
    error= 1;                                   /* force warning */
723
716
  }
724
717
 
725
 
  if (error != type::VALID)
726
 
  {
 
718
  if (error > 0)
727
719
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
728
720
                                 str->ptr(), str->length(),
729
721
                                 warn_type, warn_name);
730
 
  }
731
722
 
732
723
  return value;
733
724
}
766
757
*/
767
758
 
768
759
enum Arg_comparator::enum_date_cmp_type
769
 
Arg_comparator::can_compare_as_dates(Item *in_a, Item *in_b,
770
 
                                     int64_t *const_value)
 
760
Arg_comparator::can_compare_as_dates(Item *a, Item *b, uint64_t *const_value)
771
761
{
772
762
  enum enum_date_cmp_type cmp_type= CMP_DATE_DFLT;
773
763
  Item *str_arg= 0, *date_arg= 0;
774
764
 
775
 
  if (in_a->type() == Item::ROW_ITEM || in_b->type() == Item::ROW_ITEM)
 
765
  if (a->type() == Item::ROW_ITEM || b->type() == Item::ROW_ITEM)
776
766
    return CMP_DATE_DFLT;
777
767
 
778
 
  if (in_a->is_datetime())
 
768
  if (a->is_datetime())
779
769
  {
780
 
    if (in_b->is_datetime())
781
 
    {
 
770
    if (b->is_datetime())
782
771
      cmp_type= CMP_DATE_WITH_DATE;
783
 
    }
784
 
    else if (in_b->result_type() == STRING_RESULT)
 
772
    else if (b->result_type() == STRING_RESULT)
785
773
    {
786
774
      cmp_type= CMP_DATE_WITH_STR;
787
 
      date_arg= in_a;
788
 
      str_arg= in_b;
 
775
      date_arg= a;
 
776
      str_arg= b;
789
777
    }
790
778
  }
791
 
  else if (in_b->is_datetime() && in_a->result_type() == STRING_RESULT)
 
779
  else if (b->is_datetime() && a->result_type() == STRING_RESULT)
792
780
  {
793
781
    cmp_type= CMP_STR_WITH_DATE;
794
 
    date_arg= in_b;
795
 
    str_arg= in_a;
 
782
    date_arg= b;
 
783
    str_arg= a;
796
784
  }
797
785
 
798
786
  if (cmp_type != CMP_DATE_DFLT)
822
810
       * Does a uint64_t conversion really have to happen here?  Fields return int64_t
823
811
       * from val_int(), not uint64_t...
824
812
       */
825
 
      int64_t value;
 
813
      uint64_t value;
826
814
      String *str_val;
827
815
      String tmp;
828
816
      /* DateTime used to pick up as many string conversion possibilities as possible. */
829
 
      DateTime temporal;
 
817
      drizzled::DateTime temporal;
830
818
 
831
819
      str_val= str_arg->val_str(&tmp);
832
820
      if (! str_val)
848
836
      }
849
837
 
850
838
      /* String conversion was good.  Convert to an integer for comparison purposes. */
851
 
      temporal.to_int64_t(&value);
 
839
      int64_t int_value;
 
840
      temporal.to_int64_t(&int_value);
 
841
      value= (uint64_t) int_value;
852
842
 
853
843
      if (const_value)
854
844
        *const_value= value;
862
852
                                        Item **a1, Item **a2,
863
853
                                        Item_result type)
864
854
{
865
 
  enum_date_cmp_type cmp_type;
866
 
  int64_t const_value= -1;
 
855
  enum enum_date_cmp_type cmp_type;
 
856
  uint64_t const_value= (uint64_t)-1;
867
857
  a= a1;
868
858
  b= a2;
869
859
 
870
860
  if ((cmp_type= can_compare_as_dates(*a, *b, &const_value)))
871
861
  {
 
862
    session= current_session;
872
863
    owner= owner_arg;
873
864
    a_type= (*a)->field_type();
874
865
    b_type= (*b)->field_type();
875
866
    a_cache= 0;
876
867
    b_cache= 0;
877
868
 
878
 
    if (const_value != -1)
 
869
    if (const_value != (uint64_t)-1)
879
870
    {
880
871
      Item_cache_int *cache= new Item_cache_int();
881
872
      /* Mark the cache as non-const to prevent re-caching. */
896
887
    is_nulls_eq= test(owner && owner->functype() == Item_func::EQUAL_FUNC);
897
888
    func= &Arg_comparator::compare_datetime;
898
889
    get_value_func= &get_datetime_value;
899
 
 
900
890
    return 0;
901
891
  }
902
892
 
906
896
 
907
897
void Arg_comparator::set_datetime_cmp_func(Item **a1, Item **b1)
908
898
{
 
899
  session= current_session;
909
900
  /* A caller will handle null values by itself. */
910
901
  owner= NULL;
911
902
  a= a1;
949
940
    obtained value
950
941
*/
951
942
 
952
 
int64_t
 
943
uint64_t
953
944
get_datetime_value(Session *session, Item ***item_arg, Item **cache_arg,
954
945
                   Item *warn_item, bool *is_null)
955
946
{
956
 
  int64_t value= 0;
 
947
  uint64_t value= 0;
957
948
  String buf, *str= 0;
958
949
  Item *item= **item_arg;
959
950
 
977
968
    str= item->val_str(&buf);
978
969
    *is_null= item->null_value;
979
970
  }
980
 
 
981
971
  if (*is_null)
982
972
    return ~(uint64_t) 0;
983
 
 
984
973
  /*
985
974
    Convert strings to the integer DATE/DATETIME representation.
986
975
    Even if both dates provided in strings we can't compare them directly as
991
980
  {
992
981
    bool error;
993
982
    enum_field_types f_type= warn_item->field_type();
994
 
    type::timestamp_t t_type= f_type == DRIZZLE_TYPE_DATE ? type::DRIZZLE_TIMESTAMP_DATE : type::DRIZZLE_TIMESTAMP_DATETIME;
 
983
    enum enum_drizzle_timestamp_type t_type= f_type ==
 
984
      DRIZZLE_TYPE_DATE ? DRIZZLE_TIMESTAMP_DATE : DRIZZLE_TIMESTAMP_DATETIME;
995
985
    value= get_date_from_str(session, str, t_type, warn_item->name, &error);
996
986
    /*
997
987
      If str did not contain a valid date according to the current
1014
1004
    *cache_arg= cache;
1015
1005
    *item_arg= cache_arg;
1016
1006
  }
1017
 
 
1018
1007
  return value;
1019
1008
}
1020
1009
 
1171
1160
 
1172
1161
int Arg_comparator::compare_decimal()
1173
1162
{
1174
 
  type::Decimal value1;
1175
 
  type::Decimal *val1= (*a)->val_decimal(&value1);
 
1163
  my_decimal value1;
 
1164
  my_decimal *val1= (*a)->val_decimal(&value1);
1176
1165
  if (!(*a)->null_value)
1177
1166
  {
1178
 
    type::Decimal value2;
1179
 
    type::Decimal *val2= (*b)->val_decimal(&value2);
 
1167
    my_decimal value2;
 
1168
    my_decimal *val2= (*b)->val_decimal(&value2);
1180
1169
    if (!(*b)->null_value)
1181
1170
    {
1182
1171
      owner->null_value= 0;
1183
 
      return class_decimal_cmp(val1, val2);
 
1172
      return my_decimal_cmp(val1, val2);
1184
1173
    }
1185
1174
  }
1186
1175
  owner->null_value= 1;
1198
1187
 
1199
1188
int Arg_comparator::compare_e_decimal()
1200
1189
{
1201
 
  type::Decimal value1, value2;
1202
 
  type::Decimal *val1= (*a)->val_decimal(&value1);
1203
 
  type::Decimal *val2= (*b)->val_decimal(&value2);
 
1190
  my_decimal value1, value2;
 
1191
  my_decimal *val1= (*a)->val_decimal(&value1);
 
1192
  my_decimal *val2= (*b)->val_decimal(&value2);
1204
1193
  if ((*a)->null_value || (*b)->null_value)
1205
1194
    return test((*a)->null_value && (*b)->null_value);
1206
 
  return test(class_decimal_cmp(val1, val2) == 0);
 
1195
  return test(my_decimal_cmp(val1, val2) == 0);
1207
1196
}
1208
1197
 
1209
1198
 
1613
1602
 
1614
1603
void Item_in_optimizer::cleanup()
1615
1604
{
1616
 
  item::function::Boolean::cleanup();
 
1605
  Item_bool_func::cleanup();
1617
1606
  if (!save_cache)
1618
1607
    cache= 0;
1619
1608
  return;
1666
1655
    change records at each execution.
1667
1656
  */
1668
1657
  if ((*args) != new_item)
1669
 
    getSession().change_item_tree(args, new_item);
 
1658
    current_session->change_item_tree(args, new_item);
1670
1659
 
1671
1660
  /*
1672
1661
    Transform the right IN operand which should be an Item_in_subselect or a
1808
1797
 
1809
1798
    if (not_null_consts &&
1810
1799
        (intervals=
1811
 
          (interval_range*) memory::sql_alloc(sizeof(interval_range) * (rows - 1))))
 
1800
          (interval_range*) sql_alloc(sizeof(interval_range) * (rows - 1))))
1812
1801
    {
1813
1802
      if (use_decimal_comparison)
1814
1803
      {
1821
1810
          {
1822
1811
            range->type= DECIMAL_RESULT;
1823
1812
            range->dec.init();
1824
 
            type::Decimal *dec= el->val_decimal(&range->dec);
 
1813
            my_decimal *dec= el->val_decimal(&range->dec);
1825
1814
            if (dec != &range->dec)
1826
1815
            {
1827
1816
              range->dec= *dec;
1871
1860
{
1872
1861
  assert(fixed == 1);
1873
1862
  double value;
1874
 
  type::Decimal dec_buf, *dec= NULL;
 
1863
  my_decimal dec_buf, *dec= NULL;
1875
1864
  uint32_t i;
1876
1865
 
1877
1866
  if (use_decimal_comparison)
1879
1868
    dec= row->element_index(0)->val_decimal(&dec_buf);
1880
1869
    if (row->element_index(0)->null_value)
1881
1870
      return -1;
1882
 
    class_decimal2double(E_DEC_FATAL_ERROR, dec, &value);
 
1871
    my_decimal2double(E_DEC_FATAL_ERROR, dec, &value);
1883
1872
  }
1884
1873
  else
1885
1874
  {
1904
1893
        and we are comparing against a decimal
1905
1894
      */
1906
1895
      if (dec && range->type == DECIMAL_RESULT)
1907
 
        cmp_result= class_decimal_cmp(&range->dec, dec) <= 0;
 
1896
        cmp_result= my_decimal_cmp(&range->dec, dec) <= 0;
1908
1897
      else
1909
1898
        cmp_result= (range->dbl <= value);
1910
1899
      if (cmp_result)
1914
1903
    }
1915
1904
    interval_range *range= intervals+start;
1916
1905
    return ((dec && range->type == DECIMAL_RESULT) ?
1917
 
            class_decimal_cmp(dec, &range->dec) < 0 :
 
1906
            my_decimal_cmp(dec, &range->dec) < 0 :
1918
1907
            value < range->dbl) ? 0 : start + 1;
1919
1908
  }
1920
1909
 
1925
1914
        ((el->result_type() == DECIMAL_RESULT) ||
1926
1915
         (el->result_type() == INT_RESULT)))
1927
1916
    {
1928
 
      type::Decimal e_dec_buf, *e_dec= el->val_decimal(&e_dec_buf);
 
1917
      my_decimal e_dec_buf, *e_dec= el->val_decimal(&e_dec_buf);
1929
1918
      /* Skip NULL ranges. */
1930
1919
      if (el->null_value)
1931
1920
        continue;
1932
 
      if (class_decimal_cmp(e_dec, dec) > 0)
 
1921
      if (my_decimal_cmp(e_dec, dec) > 0)
1933
1922
        return i - 1;
1934
1923
    }
1935
1924
    else
2000
1989
  int i;
2001
1990
  bool datetime_found= false;
2002
1991
  compare_as_dates= true;
 
1992
  Session *session= current_session;
2003
1993
 
2004
1994
  /*
2005
1995
    As some compare functions are generated after sql_yacc,
2037
2027
    ge_cmp.set_datetime_cmp_func(args, args + 1);
2038
2028
    le_cmp.set_datetime_cmp_func(args, args + 2);
2039
2029
  }
2040
 
  else if (args[0]->real_item()->type() == FIELD_ITEM)
 
2030
  else if (args[0]->real_item()->type() == FIELD_ITEM &&
 
2031
           session->lex->sql_command != SQLCOM_SHOW_CREATE)
2041
2032
  {
2042
2033
    Item_field *field_item= (Item_field*) (args[0]->real_item());
2043
2034
    if (field_item->field->can_be_compared_as_int64_t())
2046
2037
        The following can't be recoded with || as convert_constant_item
2047
2038
        changes the argument
2048
2039
      */
2049
 
      if (convert_constant_item(&getSession(), field_item, &args[1]))
 
2040
      if (convert_constant_item(session, field_item, &args[1]))
2050
2041
        cmp_type=INT_RESULT;                    // Works for all types.
2051
 
      if (convert_constant_item(&getSession(), field_item, &args[2]))
 
2042
      if (convert_constant_item(session, field_item, &args[2]))
2052
2043
        cmp_type=INT_RESULT;                    // Works for all types.
2053
2044
    }
2054
2045
  }
2125
2116
  }
2126
2117
  else if (cmp_type == DECIMAL_RESULT)
2127
2118
  {
2128
 
    type::Decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf),
 
2119
    my_decimal dec_buf, *dec= args[0]->val_decimal(&dec_buf),
2129
2120
               a_buf, *a_dec, b_buf, *b_dec;
2130
2121
    if ((null_value=args[0]->null_value))
2131
2122
      return 0;
2132
2123
    a_dec= args[1]->val_decimal(&a_buf);
2133
2124
    b_dec= args[2]->val_decimal(&b_buf);
2134
2125
    if (!args[1]->null_value && !args[2]->null_value)
2135
 
      return (int64_t) ((class_decimal_cmp(dec, a_dec) >= 0 &&
2136
 
                          class_decimal_cmp(dec, b_dec) <= 0) != negated);
 
2126
      return (int64_t) ((my_decimal_cmp(dec, a_dec) >= 0 &&
 
2127
                          my_decimal_cmp(dec, b_dec) <= 0) != negated);
2137
2128
    if (args[1]->null_value && args[2]->null_value)
2138
2129
      null_value=1;
2139
2130
    else if (args[1]->null_value)
2140
 
      null_value= (class_decimal_cmp(dec, b_dec) <= 0);
 
2131
      null_value= (my_decimal_cmp(dec, b_dec) <= 0);
2141
2132
    else
2142
 
      null_value= (class_decimal_cmp(dec, a_dec) >= 0);
 
2133
      null_value= (my_decimal_cmp(dec, a_dec) >= 0);
2143
2134
  }
2144
2135
  else
2145
2136
  {
2197
2188
    max_length= max(len0, len1) + decimals + (unsigned_flag ? 0 : 1);
2198
2189
  }
2199
2190
  else
2200
 
  {
2201
2191
    max_length= max(args[0]->max_length, args[1]->max_length);
2202
 
  }
2203
2192
 
2204
2193
  switch (hybrid_type)
2205
2194
  {
2206
2195
  case STRING_RESULT:
2207
2196
    agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV, 1);
2208
2197
    break;
2209
 
 
2210
2198
  case DECIMAL_RESULT:
2211
2199
  case REAL_RESULT:
2212
2200
    break;
2213
 
 
2214
2201
  case INT_RESULT:
2215
2202
    decimals= 0;
2216
2203
    break;
2217
 
 
2218
2204
  case ROW_RESULT:
 
2205
  default:
2219
2206
    assert(0);
2220
2207
  }
2221
 
 
2222
2208
  cached_field_type= agg_field_type(args, 2);
2223
2209
}
2224
2210
 
2273
2259
}
2274
2260
 
2275
2261
 
2276
 
type::Decimal *Item_func_ifnull::decimal_op(type::Decimal *decimal_value)
 
2262
my_decimal *Item_func_ifnull::decimal_op(my_decimal *decimal_value)
2277
2263
{
2278
2264
  assert(fixed == 1);
2279
 
  type::Decimal *value= args[0]->val_decimal(decimal_value);
 
2265
  my_decimal *value= args[0]->val_decimal(decimal_value);
2280
2266
  if (!args[0]->null_value)
2281
2267
  {
2282
2268
    null_value= 0;
2446
2432
}
2447
2433
 
2448
2434
 
2449
 
type::Decimal *
2450
 
Item_func_if::val_decimal(type::Decimal *decimal_value)
 
2435
my_decimal *
 
2436
Item_func_if::val_decimal(my_decimal *decimal_value)
2451
2437
{
2452
2438
  assert(fixed == 1);
2453
2439
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
2454
 
  type::Decimal *value= arg->val_decimal(decimal_value);
 
2440
  my_decimal *value= arg->val_decimal(decimal_value);
2455
2441
  null_value= arg->null_value;
2456
2442
  return value;
2457
2443
}
2531
2517
}
2532
2518
 
2533
2519
 
2534
 
type::Decimal *
2535
 
Item_func_nullif::val_decimal(type::Decimal * decimal_value)
 
2520
my_decimal *
 
2521
Item_func_nullif::val_decimal(my_decimal * decimal_value)
2536
2522
{
2537
2523
  assert(fixed == 1);
2538
 
  type::Decimal *res;
 
2524
  my_decimal *res;
2539
2525
  if (!cmp.compare())
2540
2526
  {
2541
2527
    null_value=1;
2668
2654
}
2669
2655
 
2670
2656
 
2671
 
type::Decimal *Item_func_case::val_decimal(type::Decimal *decimal_value)
 
2657
my_decimal *Item_func_case::val_decimal(my_decimal *decimal_value)
2672
2658
{
2673
2659
  assert(fixed == 1);
2674
2660
  char buff[MAX_FIELD_WIDTH];
2675
2661
  String dummy_str(buff, sizeof(buff), default_charset());
2676
2662
  Item *item= find_item(&dummy_str);
2677
 
  type::Decimal *res;
 
2663
  my_decimal *res;
2678
2664
 
2679
2665
  if (!item)
2680
2666
  {
2717
2703
 
2718
2704
void Item_func_case::agg_num_lengths(Item *arg)
2719
2705
{
2720
 
  uint32_t len= class_decimal_length_to_precision(arg->max_length, arg->decimals,
 
2706
  uint32_t len= my_decimal_length_to_precision(arg->max_length, arg->decimals,
2721
2707
                                           arg->unsigned_flag) - arg->decimals;
2722
2708
  set_if_bigger(max_length, len);
2723
2709
  set_if_bigger(decimals, arg->decimals);
2730
2716
  Item **agg;
2731
2717
  uint32_t nagg;
2732
2718
  uint32_t found_types= 0;
2733
 
  if (!(agg= (Item**) memory::sql_alloc(sizeof(Item*)*(ncases+1))))
 
2719
  if (!(agg= (Item**) sql_alloc(sizeof(Item*)*(ncases+1))))
2734
2720
    return;
2735
2721
 
2736
2722
  /*
2756
2742
  */
2757
2743
  if (first_expr_num != -1)
2758
2744
  {
 
2745
    uint32_t i;
2759
2746
    agg[0]= args[first_expr_num];
2760
2747
    left_result_type= agg[0]->result_type();
2761
2748
 
2765
2752
    if (!(found_types= collect_cmp_types(agg, nagg)))
2766
2753
      return;
2767
2754
 
2768
 
    for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
 
2755
    for (i= 0; i <= (uint32_t)DECIMAL_RESULT; i++)
2769
2756
    {
2770
2757
      if (found_types & (1 << i) && !cmp_items[i])
2771
2758
      {
2800
2787
      agg_num_lengths(args[i + 1]);
2801
2788
    if (else_expr_num != -1)
2802
2789
      agg_num_lengths(args[else_expr_num]);
2803
 
    max_length= class_decimal_precision_to_length(max_length + decimals, decimals,
 
2790
    max_length= my_decimal_precision_to_length(max_length + decimals, decimals,
2804
2791
                                               unsigned_flag);
2805
2792
  }
2806
2793
}
2851
2838
 
2852
2839
void Item_func_case::cleanup()
2853
2840
{
 
2841
  uint32_t i;
2854
2842
  Item_func::cleanup();
2855
 
  for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
 
2843
  for (i= 0; i <= (uint32_t)DECIMAL_RESULT; i++)
2856
2844
  {
2857
2845
    delete cmp_items[i];
2858
2846
    cmp_items[i]= 0;
2859
2847
  }
 
2848
  return;
2860
2849
}
2861
2850
 
2862
2851
 
2907
2896
}
2908
2897
 
2909
2898
 
2910
 
type::Decimal *Item_func_coalesce::decimal_op(type::Decimal *decimal_value)
 
2899
my_decimal *Item_func_coalesce::decimal_op(my_decimal *decimal_value)
2911
2900
{
2912
2901
  assert(fixed == 1);
2913
2902
  null_value= 0;
2914
2903
  for (uint32_t i= 0; i < arg_count; i++)
2915
2904
  {
2916
 
    type::Decimal *res= args[i]->val_decimal(decimal_value);
 
2905
    my_decimal *res= args[i]->val_decimal(decimal_value);
2917
2906
    if (!args[i]->null_value)
2918
2907
      return res;
2919
2908
  }
2926
2915
{
2927
2916
  cached_field_type= agg_field_type(args, arg_count);
2928
2917
  agg_result_type(&hybrid_type, args, arg_count);
2929
 
 
2930
2918
  switch (hybrid_type) {
2931
2919
  case STRING_RESULT:
2932
2920
    count_only_length();
2933
2921
    decimals= NOT_FIXED_DEC;
2934
2922
    agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1);
2935
2923
    break;
2936
 
 
2937
2924
  case DECIMAL_RESULT:
2938
2925
    count_decimal_length();
2939
2926
    break;
2940
 
 
2941
2927
  case REAL_RESULT:
2942
2928
    count_real_length();
2943
2929
    break;
2944
 
 
2945
2930
  case INT_RESULT:
2946
2931
    count_only_length();
2947
2932
    decimals= 0;
2948
2933
    break;
2949
 
 
2950
2934
  case ROW_RESULT:
 
2935
  default:
2951
2936
    assert(0);
2952
2937
  }
2953
2938
}
3062
3047
}
3063
3048
 
3064
3049
 
3065
 
static int cmp_decimal(void *, type::Decimal *a, type::Decimal *b)
 
3050
static int cmp_decimal(void *, my_decimal *a, my_decimal *b)
3066
3051
{
3067
3052
  /*
3068
3053
    We need call of fixing buffer pointer, because fast sort just copy
3070
3055
  */
3071
3056
  a->fix_buffer_pointer();
3072
3057
  b->fix_buffer_pointer();
3073
 
  return class_decimal_cmp(a, b);
3074
 
}
3075
 
 
3076
 
 
3077
 
void in_vector::sort()
3078
 
{
3079
 
  internal::my_qsort2(base,used_count,size,compare, (void *) collation);
 
3058
  return my_decimal_cmp(a, b);
3080
3059
}
3081
3060
 
3082
3061
 
3111
3090
{
3112
3091
  if (base)
3113
3092
  {
3114
 
    // base was allocated with help of memory::sql_alloc => following is OK
 
3093
    // base was allocated with help of sql_alloc => following is OK
3115
3094
    for (uint32_t i=0 ; i < count ; i++)
3116
3095
      ((String*) base)[i].free();
3117
3096
  }
3178
3157
  return;
3179
3158
}
3180
3159
 
3181
 
in_int64_t::in_int64_t(uint32_t elements) :
3182
 
  in_vector(elements, sizeof(packed_int64_t),(qsort2_cmp) cmp_int64_t, 0)
 
3160
in_int64_t::in_int64_t(uint32_t elements)
 
3161
  :in_vector(elements,sizeof(packed_int64_t),(qsort2_cmp) cmp_int64_t, 0)
3183
3162
{}
3184
3163
 
3185
3164
void in_int64_t::set(uint32_t pos,Item *item)
3199
3178
  return (unsigned char*) &tmp;
3200
3179
}
3201
3180
 
3202
 
void in_datetime::set(uint32_t pos, Item *item)
 
3181
void in_datetime::set(uint32_t pos,Item *item)
3203
3182
{
3204
3183
  Item **tmp_item= &item;
3205
3184
  bool is_null;
3239
3218
 
3240
3219
 
3241
3220
in_decimal::in_decimal(uint32_t elements)
3242
 
  :in_vector(elements, sizeof(type::Decimal),(qsort2_cmp) cmp_decimal, 0)
 
3221
  :in_vector(elements, sizeof(my_decimal),(qsort2_cmp) cmp_decimal, 0)
3243
3222
{}
3244
3223
 
3245
3224
 
3246
3225
void in_decimal::set(uint32_t pos, Item *item)
3247
3226
{
3248
 
  /* as far as 'item' is constant, we can store reference on type::Decimal */
3249
 
  type::Decimal *dec= ((type::Decimal *)base) + pos;
 
3227
  /* as far as 'item' is constant, we can store reference on my_decimal */
 
3228
  my_decimal *dec= ((my_decimal *)base) + pos;
3250
3229
  dec->len= DECIMAL_BUFF_LENGTH;
3251
3230
  dec->fix_buffer_pointer();
3252
 
  type::Decimal *res= item->val_decimal(dec);
 
3231
  my_decimal *res= item->val_decimal(dec);
3253
3232
  /* if item->val_decimal() is evaluated to NULL then res == 0 */
3254
3233
  if (!item->null_value && res != dec)
3255
 
    class_decimal2decimal(res, dec);
 
3234
    my_decimal2decimal(res, dec);
3256
3235
}
3257
3236
 
3258
3237
 
3259
3238
unsigned char *in_decimal::get_value(Item *item)
3260
3239
{
3261
 
  type::Decimal *result= item->val_decimal(&val);
 
3240
  my_decimal *result= item->val_decimal(&val);
3262
3241
  if (item->null_value)
3263
3242
    return 0;
3264
3243
  return (unsigned char *)result;
3271
3250
  switch (type) {
3272
3251
  case STRING_RESULT:
3273
3252
    return new cmp_item_sort_string(cs);
3274
 
 
3275
3253
  case INT_RESULT:
3276
3254
    return new cmp_item_int;
3277
 
 
3278
3255
  case REAL_RESULT:
3279
3256
    return new cmp_item_real;
3280
 
 
3281
3257
  case ROW_RESULT:
3282
3258
    return new cmp_item_row;
3283
 
 
3284
3259
  case DECIMAL_RESULT:
3285
3260
    return new cmp_item_decimal;
 
3261
  default:
 
3262
    assert(0);
 
3263
    break;
3286
3264
  }
3287
 
 
3288
3265
  return 0; // to satisfy compiler :)
3289
3266
}
3290
3267
 
3363
3340
    return;
3364
3341
  }
3365
3342
  n= tmpl->n;
3366
 
  if ((comparators= (cmp_item **) memory::sql_alloc(sizeof(cmp_item *)*n)))
 
3343
  if ((comparators= (cmp_item **) sql_alloc(sizeof(cmp_item *)*n)))
3367
3344
  {
3368
3345
    item->bring_value();
3369
3346
    item->null_value= 0;
3417
3394
 
3418
3395
void cmp_item_decimal::store_value(Item *item)
3419
3396
{
3420
 
  type::Decimal *val= item->val_decimal(&value);
 
3397
  my_decimal *val= item->val_decimal(&value);
3421
3398
  /* val may be zero if item is nnull */
3422
3399
  if (val && val != &value)
3423
 
    class_decimal2decimal(val, &value);
 
3400
    my_decimal2decimal(val, &value);
3424
3401
}
3425
3402
 
3426
3403
 
3427
3404
int cmp_item_decimal::cmp(Item *arg)
3428
3405
{
3429
 
  type::Decimal tmp_buf, *tmp= arg->val_decimal(&tmp_buf);
 
3406
  my_decimal tmp_buf, *tmp= arg->val_decimal(&tmp_buf);
3430
3407
  if (arg->null_value)
3431
3408
    return 1;
3432
 
  return class_decimal_cmp(&value, tmp);
 
3409
  return my_decimal_cmp(&value, tmp);
3433
3410
}
3434
3411
 
3435
3412
 
3436
3413
int cmp_item_decimal::compare(cmp_item *arg)
3437
3414
{
3438
3415
  cmp_item_decimal *l_cmp= (cmp_item_decimal*) arg;
3439
 
  return class_decimal_cmp(&value, &l_cmp->value);
 
3416
  return my_decimal_cmp(&value, &l_cmp->value);
3440
3417
}
3441
3418
 
3442
3419
 
3549
3526
{
3550
3527
  Item **arg, **arg_end;
3551
3528
  bool const_itm= 1;
 
3529
  Session *session= current_session;
3552
3530
  bool datetime_found= false;
3553
3531
  /* true <=> arguments values will be compared as DATETIMEs. */
3554
3532
  bool compare_as_datetime= false;
3555
3533
  Item *date_arg= 0;
3556
3534
  uint32_t found_types= 0;
3557
 
  uint32_t type_cnt= 0;
 
3535
  uint32_t type_cnt= 0, i;
3558
3536
  Item_result cmp_type= STRING_RESULT;
3559
3537
  left_result_type= args[0]->result_type();
3560
3538
  if (!(found_types= collect_cmp_types(args, arg_count, true)))
3568
3546
      break;
3569
3547
    }
3570
3548
  }
3571
 
  for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
 
3549
  for (i= 0; i <= (uint32_t)DECIMAL_RESULT; i++)
3572
3550
  {
3573
3551
    if (found_types & 1 << i)
3574
3552
    {
3675
3653
  if (type_cnt == 1 && const_itm && !nulls_in_row())
3676
3654
  {
3677
3655
    if (compare_as_datetime)
3678
 
    {
3679
3656
      array= new in_datetime(date_arg, arg_count - 1);
3680
 
    }
3681
3657
    else
3682
3658
    {
3683
3659
      /*
3688
3664
        comparison type accordingly.
3689
3665
      */
3690
3666
      if (args[0]->real_item()->type() == FIELD_ITEM &&
 
3667
          session->lex->sql_command != SQLCOM_SHOW_CREATE &&
3691
3668
          cmp_type != INT_RESULT)
3692
3669
      {
3693
3670
        Item_field *field_item= (Item_field*) (args[0]->real_item());
3696
3673
          bool all_converted= true;
3697
3674
          for (arg=args+1, arg_end=args+arg_count; arg != arg_end ; arg++)
3698
3675
          {
3699
 
            if (!convert_constant_item (&getSession(), field_item, &arg[0]))
 
3676
            if (!convert_constant_item (session, field_item, &arg[0]))
3700
3677
              all_converted= false;
3701
3678
          }
3702
3679
          if (all_converted)
3703
3680
            cmp_type= INT_RESULT;
3704
3681
        }
3705
3682
      }
3706
 
 
3707
3683
      switch (cmp_type) {
3708
3684
      case STRING_RESULT:
3709
3685
        array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in,
3710
3686
                            cmp_collation.collation);
3711
3687
        break;
3712
 
 
3713
3688
      case INT_RESULT:
3714
3689
        array= new in_int64_t(arg_count-1);
3715
3690
        break;
3716
 
 
3717
3691
      case REAL_RESULT:
3718
3692
        array= new in_double(arg_count-1);
3719
3693
        break;
3720
 
 
3721
3694
      case ROW_RESULT:
3722
3695
        /*
3723
3696
          The row comparator was created at the beginning but only DATETIME
3726
3699
        */
3727
3700
        ((in_row*)array)->tmp.store_value(args[0]);
3728
3701
        break;
3729
 
 
3730
3702
      case DECIMAL_RESULT:
3731
3703
        array= new in_decimal(arg_count - 1);
3732
3704
        break;
 
3705
      default:
 
3706
        assert(0);
 
3707
        return;
3733
3708
      }
3734
3709
    }
3735
 
 
3736
 
    if (array && !(getSession().is_fatal_error))                // If not EOM
 
3710
    if (array && !(session->is_fatal_error))            // If not EOM
3737
3711
    {
3738
3712
      uint32_t j=0;
3739
3713
      for (uint32_t arg_num=1 ; arg_num < arg_count ; arg_num++)
3740
3714
      {
3741
 
        if (!args[arg_num]->null_value)                 // Skip NULL values
 
3715
        if (!args[arg_num]->null_value)                 // Skip NULL values
3742
3716
        {
3743
3717
          array->set(j,args[arg_num]);
3744
 
          j++;
 
3718
          j++;
3745
3719
        }
3746
 
        else
3747
 
          have_null= 1;
 
3720
        else
 
3721
          have_null= 1;
3748
3722
      }
3749
3723
      if ((array->used_count= j))
3750
 
        array->sort();
 
3724
        array->sort();
3751
3725
    }
3752
3726
  }
3753
3727
  else
3756
3730
      cmp_items[STRING_RESULT]= new cmp_item_datetime(date_arg);
3757
3731
    else
3758
3732
    {
3759
 
      for (int i= STRING_RESULT; i <= DECIMAL_RESULT; i++)
 
3733
      for (i= 0; i <= (uint32_t) DECIMAL_RESULT; i++)
3760
3734
      {
3761
3735
        if (found_types & (1 << i) && !cmp_items[i])
3762
3736
        {
3849
3823
 
3850
3824
 
3851
3825
Item_cond::Item_cond(Session *session, Item_cond *item)
3852
 
  :item::function::Boolean(session, item),
 
3826
  :Item_bool_func(session, item),
3853
3827
   abort_on_null(item->abort_on_null),
3854
3828
   and_tables_cache(item->and_tables_cache)
3855
3829
{
3876
3850
  void *orig_session_marker= session->session_marker;
3877
3851
  unsigned char buff[sizeof(char*)];                    // Max local vars in function
3878
3852
  not_null_tables_cache= used_tables_cache= 0;
3879
 
  const_item_cache= true;
 
3853
  const_item_cache= 1;
3880
3854
 
3881
3855
  if (functype() == COND_OR_FUNC)
3882
3856
    session->session_marker= 0;
3951
3925
  Item *item;
3952
3926
 
3953
3927
  used_tables_cache=0;
3954
 
  const_item_cache= true;
 
3928
  const_item_cache=1;
3955
3929
 
3956
3930
  and_tables_cache= ~(table_map) 0; // Here and below we do as fix_fields does
3957
3931
  not_null_tables_cache= 0;
4023
3997
      change records at each execution.
4024
3998
    */
4025
3999
    if (new_item != item)
4026
 
      getSession().change_item_tree(li.ref(), new_item);
 
4000
      current_session->change_item_tree(li.ref(), new_item);
4027
4001
  }
4028
4002
  return Item_func::transform(transformer, arg);
4029
4003
}
4140
4114
  Item *item;
4141
4115
 
4142
4116
  used_tables_cache=0;
4143
 
  const_item_cache= true;
 
4117
  const_item_cache=1;
4144
4118
  while ((item=li++))
4145
4119
  {
4146
4120
    item->update_used_tables();
4372
4346
                    res->ptr(),res->ptr()+res->length(),
4373
4347
                    res2->ptr(),res2->ptr()+res2->length(),
4374
4348
                    make_escape_code(cmp.cmp_collation.collation, escape),
4375
 
                    internal::wild_one,internal::wild_many) ? 0 : 1;
 
4349
                    wild_one,wild_many) ? 0 : 1;
4376
4350
}
4377
4351
 
4378
4352
 
4389
4363
    if (!res2)
4390
4364
      return OPTIMIZE_NONE;
4391
4365
 
4392
 
    if (*res2->ptr() != internal::wild_many)
 
4366
    if (*res2->ptr() != wild_many)
4393
4367
    {
4394
 
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != internal::wild_one)
 
4368
      if (args[0]->result_type() != STRING_RESULT || *res2->ptr() != wild_one)
4395
4369
        return OPTIMIZE_OP;
4396
4370
    }
4397
4371
  }
4419
4393
    String *escape_str= escape_item->val_str(&tmp_value1);
4420
4394
    if (escape_str)
4421
4395
    {
4422
 
      escape= (char *)memory::sql_alloc(escape_str->length());
 
4396
      escape= (char *)sql_alloc(escape_str->length());
4423
4397
      strcpy(escape, escape_str->ptr()); 
4424
4398
    }
4425
4399
    else
4426
4400
    {
4427
 
      escape= (char *)memory::sql_alloc(1);
 
4401
      escape= (char *)sql_alloc(1);
4428
4402
      strcpy(escape, "\\");
4429
4403
    } 
4430
4404
   
4447
4421
      */
4448
4422
 
4449
4423
      if (len > MIN_TURBOBM_PATTERN_LEN + 2 &&
4450
 
          *first == internal::wild_many &&
4451
 
          *last  == internal::wild_many)
 
4424
          *first == wild_many &&
 
4425
          *last  == wild_many)
4452
4426
      {
4453
4427
        const char* tmp = first + 1;
4454
 
        for (; *tmp != internal::wild_many && *tmp != internal::wild_one; tmp++)
 
4428
        for (; *tmp != wild_many && *tmp != wild_one; tmp++)
4455
4429
        {
4456
4430
          if (escape == tmp)
4457
4431
            break;
4463
4437
      {
4464
4438
        pattern     = first + 1;
4465
4439
        pattern_len = (int) len - 2;
4466
 
        int *suff = (int*) session->getMemRoot()->allocate((int) (sizeof(int)*
4467
 
                                                                  ((pattern_len + 1)*2+
4468
 
                                                                   alphabet_size)));
 
4440
        int *suff = (int*) session->alloc((int) (sizeof(int)*
 
4441
                                      ((pattern_len + 1)*2+
 
4442
                                      alphabet_size)));
4469
4443
        bmGs      = suff + pattern_len + 1;
4470
4444
        bmBc      = bmGs + pattern_len + 1;
4471
4445
        turboBM_compute_good_suffix_shifts(suff);
4482
4456
  Item_bool_func2::cleanup();
4483
4457
}
4484
4458
 
4485
 
static unsigned char likeconv(const CHARSET_INFO *cs, unsigned char a)
4486
 
{
4487
4459
#ifdef LIKE_CMP_TOUPPER
4488
 
  return cs->toupper(a);
 
4460
#define likeconv(cs,A) (unsigned char) (cs)->toupper(A)
4489
4461
#else
4490
 
  return cs->sort_order[a];
 
4462
#define likeconv(cs,A) (unsigned char) (cs)->sort_order[(unsigned char) (A)]
4491
4463
#endif
4492
 
}
 
4464
 
4493
4465
 
4494
4466
/**
4495
4467
  Precomputation dependent only on pattern_len.
4884
4856
}
4885
4857
 
4886
4858
Item_equal::Item_equal(Item_field *f1, Item_field *f2)
4887
 
  : item::function::Boolean(), const_item(0), eval_item(0), cond_false(0)
 
4859
  : Item_bool_func(), const_item(0), eval_item(0), cond_false(0)
4888
4860
{
4889
 
  const_item_cache= false;
 
4861
  const_item_cache= 0;
4890
4862
  fields.push_back(f1);
4891
4863
  fields.push_back(f2);
4892
4864
}
4893
4865
 
4894
4866
Item_equal::Item_equal(Item *c, Item_field *f)
4895
 
  : item::function::Boolean(), eval_item(0), cond_false(0)
 
4867
  : Item_bool_func(), eval_item(0), cond_false(0)
4896
4868
{
4897
 
  const_item_cache= false;
 
4869
  const_item_cache= 0;
4898
4870
  fields.push_back(f);
4899
4871
  const_item= c;
4900
4872
}
4901
4873
 
4902
4874
 
4903
4875
Item_equal::Item_equal(Item_equal *item_equal)
4904
 
  : item::function::Boolean(), eval_item(0), cond_false(0)
 
4876
  : Item_bool_func(), eval_item(0), cond_false(0)
4905
4877
{
4906
 
  const_item_cache= false;
 
4878
  const_item_cache= 0;
4907
4879
  List_iterator_fast<Item_field> li(item_equal->fields);
4908
4880
  Item_field *item;
4909
4881
  while ((item= li++))
4927
4899
  func->set_cmp_func();
4928
4900
  func->quick_fix_field();
4929
4901
  if ((cond_false= !func->val_int()))
4930
 
    const_item_cache= true;
 
4902
    const_item_cache= 1;
4931
4903
}
4932
4904
 
4933
4905
void Item_equal::add(Item_field *f)
5073
5045
  List_iterator_fast<Item_field> li(fields);
5074
5046
  Item *item;
5075
5047
  not_null_tables_cache= used_tables_cache= 0;
5076
 
  const_item_cache= false;
 
5048
  const_item_cache= 0;
5077
5049
  while ((item= li++))
5078
5050
  {
5079
5051
    table_map tmp_table_map;
5110
5082
    return 0;
5111
5083
  List_iterator_fast<Item_field> it(fields);
5112
5084
  Item *item= const_item ? const_item : it++;
 
5085
  if ((null_value= item->null_value))
 
5086
    return 0;
5113
5087
  eval_item->store_value(item);
5114
 
  if ((null_value= item->null_value))
5115
 
    return 0;
5116
5088
  while ((item_field= it++))
5117
5089
  {
5118
5090
    /* Skip fields of non-const tables. They haven't been read yet */
5119
 
    if (item_field->field->getTable()->const_table)
 
5091
    if (item_field->field->table->const_table)
5120
5092
    {
5121
 
      if (eval_item->cmp(item_field) || (null_value= item_field->null_value))
 
5093
      if ((null_value= item_field->null_value) || eval_item->cmp(item_field))
5122
5094
        return 0;
5123
5095
    }
5124
5096
  }
5161
5133
      change records at each execution.
5162
5134
    */
5163
5135
    if (new_item != item)
5164
 
      getSession().change_item_tree((Item **) it.ref(), new_item);
 
5136
      current_session->change_item_tree((Item **) it.ref(), new_item);
5165
5137
  }
5166
5138
  return Item_func::transform(transformer, arg);
5167
5139
}
5188
5160
  str->append(')');
5189
5161
}
5190
5162
 
5191
 
} /* namespace drizzled */