← 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: 2010-12-18 02:06:13 UTC
  • Revision ID: brian@tangent.org-20101218020613-8lxhcvsy812bu960
Formatting + remove default from switch/case.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/cmpfunc.cc
570
570
{
571
571
  owner= item;
572
572
  func= comparator_matrix[type]
573
 
                         [test(owner->functype() == Item_func::EQUAL_FUNC)];
 
573
    [test(owner->functype() == Item_func::EQUAL_FUNC)];
 
574
 
574
575
  switch (type) {
575
576
  case ROW_RESULT:
576
 
  {
577
 
    uint32_t n= (*a)->cols();
578
 
    if (n != (*b)->cols())
579
 
    {
580
 
      my_error(ER_OPERAND_COLUMNS, MYF(0), n);
581
 
      comparators= 0;
582
 
      return 1;
583
 
    }
584
 
    if (!(comparators= new Arg_comparator[n]))
585
 
      return 1;
586
 
    for (uint32_t i=0; i < n; i++)
587
 
    {
588
 
      if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
589
 
      {
590
 
        my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->element_index(i)->cols());
591
 
        return 1;
592
 
      }
593
 
      comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
594
 
    }
595
 
    break;
596
 
  }
 
577
    {
 
578
      uint32_t n= (*a)->cols();
 
579
      if (n != (*b)->cols())
 
580
      {
 
581
        my_error(ER_OPERAND_COLUMNS, MYF(0), n);
 
582
        comparators= 0;
 
583
        return 1;
 
584
      }
 
585
      if (!(comparators= new Arg_comparator[n]))
 
586
        return 1;
 
587
      for (uint32_t i=0; i < n; i++)
 
588
      {
 
589
        if ((*a)->element_index(i)->cols() != (*b)->element_index(i)->cols())
 
590
        {
 
591
          my_error(ER_OPERAND_COLUMNS, MYF(0), (*a)->element_index(i)->cols());
 
592
          return 1;
 
593
        }
 
594
        comparators[i].set_cmp_func(owner, (*a)->addr(i), (*b)->addr(i));
 
595
      }
 
596
      break;
 
597
    }
 
598
 
597
599
  case STRING_RESULT:
598
 
  {
599
 
    /*
600
 
      We must set cmp_charset here as we may be called from for an automatic
601
 
      generated item, like in natural join
602
 
    */
603
 
    if (cmp_collation.set((*a)->collation, (*b)->collation) ||
604
 
        cmp_collation.derivation == DERIVATION_NONE)
605
 
    {
606
 
      my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
607
 
      return 1;
608
 
    }
609
 
    if (cmp_collation.collation == &my_charset_bin)
610
600
    {
611
601
      /*
612
 
        We are using BLOB/BINARY/VARBINARY, change to compare byte by byte,
613
 
        without removing end space
 
602
        We must set cmp_charset here as we may be called from for an automatic
 
603
        generated item, like in natural join
614
604
      */
615
 
      if (func == &Arg_comparator::compare_string)
616
 
        func= &Arg_comparator::compare_binary_string;
617
 
      else if (func == &Arg_comparator::compare_e_string)
618
 
        func= &Arg_comparator::compare_e_binary_string;
 
605
      if (cmp_collation.set((*a)->collation, (*b)->collation) ||
 
606
          cmp_collation.derivation == DERIVATION_NONE)
 
607
      {
 
608
        my_coll_agg_error((*a)->collation, (*b)->collation, owner->func_name());
 
609
        return 1;
 
610
      }
 
611
      if (cmp_collation.collation == &my_charset_bin)
 
612
      {
 
613
        /*
 
614
          We are using BLOB/BINARY/VARBINARY, change to compare byte by byte,
 
615
          without removing end space
 
616
        */
 
617
        if (func == &Arg_comparator::compare_string)
 
618
          func= &Arg_comparator::compare_binary_string;
 
619
        else if (func == &Arg_comparator::compare_e_string)
 
620
          func= &Arg_comparator::compare_e_binary_string;
619
621
 
620
 
      /*
621
 
        As this is binary compassion, mark all fields that they can't be
622
 
        transformed. Otherwise we would get into trouble with comparisons
623
 
        like:
624
 
        WHERE col= 'j' AND col LIKE BINARY 'j'
625
 
        which would be transformed to:
626
 
        WHERE col= 'j'
 
622
        /*
 
623
          As this is binary compassion, mark all fields that they can't be
 
624
          transformed. Otherwise we would get into trouble with comparisons
 
625
like:
 
626
WHERE col= 'j' AND col LIKE BINARY 'j'
 
627
which would be transformed to:
 
628
WHERE col= 'j'
627
629
      */
628
 
      (*a)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
629
 
      (*b)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
 
630
        (*a)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
 
631
        (*b)->walk(&Item::set_no_const_sub, false, (unsigned char*) 0);
 
632
      }
 
633
      break;
630
634
    }
631
 
    break;
632
 
  }
633
635
  case INT_RESULT:
634
 
  {
635
 
    if (func == &Arg_comparator::compare_int_signed)
636
 
    {
637
 
      if ((*a)->unsigned_flag)
638
 
        func= (((*b)->unsigned_flag)?
639
 
               &Arg_comparator::compare_int_unsigned :
640
 
               &Arg_comparator::compare_int_unsigned_signed);
641
 
      else if ((*b)->unsigned_flag)
642
 
        func= &Arg_comparator::compare_int_signed_unsigned;
643
 
    }
644
 
    else if (func== &Arg_comparator::compare_e_int)
645
 
    {
646
 
      if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
647
 
        func= &Arg_comparator::compare_e_int_diff_signedness;
648
 
    }
649
 
    break;
650
 
  }
 
636
    {
 
637
      if (func == &Arg_comparator::compare_int_signed)
 
638
      {
 
639
        if ((*a)->unsigned_flag)
 
640
          func= (((*b)->unsigned_flag)?
 
641
                 &Arg_comparator::compare_int_unsigned :
 
642
                 &Arg_comparator::compare_int_unsigned_signed);
 
643
        else if ((*b)->unsigned_flag)
 
644
          func= &Arg_comparator::compare_int_signed_unsigned;
 
645
      }
 
646
      else if (func== &Arg_comparator::compare_e_int)
 
647
      {
 
648
        if ((*a)->unsigned_flag ^ (*b)->unsigned_flag)
 
649
          func= &Arg_comparator::compare_e_int_diff_signedness;
 
650
      }
 
651
      break;
 
652
    }
651
653
  case DECIMAL_RESULT:
652
654
    break;
653
655
  case REAL_RESULT:
654
 
  {
655
 
    if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
656
656
    {
657
 
      precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
658
 
      if (func == &Arg_comparator::compare_real)
659
 
        func= &Arg_comparator::compare_real_fixed;
660
 
      else if (func == &Arg_comparator::compare_e_real)
661
 
        func= &Arg_comparator::compare_e_real_fixed;
 
657
      if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
 
658
      {
 
659
        precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
 
660
        if (func == &Arg_comparator::compare_real)
 
661
          func= &Arg_comparator::compare_real_fixed;
 
662
        else if (func == &Arg_comparator::compare_e_real)
 
663
          func= &Arg_comparator::compare_e_real_fixed;
 
664
      }
 
665
      break;
662
666
    }
663
 
    break;
664
 
  }
665
 
  default:
666
 
    assert(0);
667
 
  }
 
667
  }
 
668
 
668
669
  return 0;
669
670
}
670
671
 
2195
2196
    max_length= max(len0, len1) + decimals + (unsigned_flag ? 0 : 1);
2196
2197
  }
2197
2198
  else
 
2199
  {
2198
2200
    max_length= max(args[0]->max_length, args[1]->max_length);
 
2201
  }
2199
2202
 
2200
2203
  switch (hybrid_type)
2201
2204
  {
2202
2205
  case STRING_RESULT:
2203
2206
    agg_arg_charsets(collation, args, arg_count, MY_COLL_CMP_CONV, 1);
2204
2207
    break;
 
2208
 
2205
2209
  case DECIMAL_RESULT:
2206
2210
  case REAL_RESULT:
2207
2211
    break;
 
2212
 
2208
2213
  case INT_RESULT:
2209
2214
    decimals= 0;
2210
2215
    break;
 
2216
 
2211
2217
  case ROW_RESULT:
2212
 
  default:
2213
2218
    assert(0);
2214
2219
  }
 
2220
 
2215
2221
  cached_field_type= agg_field_type(args, 2);
2216
2222
}
2217
2223
 
2919
2925
{
2920
2926
  cached_field_type= agg_field_type(args, arg_count);
2921
2927
  agg_result_type(&hybrid_type, args, arg_count);
 
2928
 
2922
2929
  switch (hybrid_type) {
2923
2930
  case STRING_RESULT:
2924
2931
    count_only_length();
2925
2932
    decimals= NOT_FIXED_DEC;
2926
2933
    agg_arg_charsets(collation, args, arg_count, MY_COLL_ALLOW_CONV, 1);
2927
2934
    break;
 
2935
 
2928
2936
  case DECIMAL_RESULT:
2929
2937
    count_decimal_length();
2930
2938
    break;
 
2939
 
2931
2940
  case REAL_RESULT:
2932
2941
    count_real_length();
2933
2942
    break;
 
2943
 
2934
2944
  case INT_RESULT:
2935
2945
    count_only_length();
2936
2946
    decimals= 0;
2937
2947
    break;
 
2948
 
2938
2949
  case ROW_RESULT:
2939
 
  default:
2940
2950
    assert(0);
2941
2951
  }
2942
2952
}
3260
3270
  switch (type) {
3261
3271
  case STRING_RESULT:
3262
3272
    return new cmp_item_sort_string(cs);
 
3273
 
3263
3274
  case INT_RESULT:
3264
3275
    return new cmp_item_int;
 
3276
 
3265
3277
  case REAL_RESULT:
3266
3278
    return new cmp_item_real;
 
3279
 
3267
3280
  case ROW_RESULT:
3268
3281
    return new cmp_item_row;
 
3282
 
3269
3283
  case DECIMAL_RESULT:
3270
3284
    return new cmp_item_decimal;
3271
 
  default:
3272
 
    assert(0);
3273
 
    break;
3274
3285
  }
 
3286
 
3275
3287
  return 0; // to satisfy compiler :)
3276
3288
}
3277
3289
 
3663
3675
  if (type_cnt == 1 && const_itm && !nulls_in_row())
3664
3676
  {
3665
3677
    if (compare_as_datetime)
 
3678
    {
3666
3679
      array= new in_datetime(date_arg, arg_count - 1);
 
3680
    }
3667
3681
    else
3668
3682
    {
3669
3683
      /*
3689
3703
            cmp_type= INT_RESULT;
3690
3704
        }
3691
3705
      }
 
3706
 
3692
3707
      switch (cmp_type) {
3693
3708
      case STRING_RESULT:
3694
3709
        array=new in_string(arg_count-1,(qsort2_cmp) srtcmp_in,
3695
3710
                            cmp_collation.collation);
3696
3711
        break;
 
3712
 
3697
3713
      case INT_RESULT:
3698
3714
        array= new in_int64_t(arg_count-1);
3699
3715
        break;
 
3716
 
3700
3717
      case REAL_RESULT:
3701
3718
        array= new in_double(arg_count-1);
3702
3719
        break;
 
3720
 
3703
3721
      case ROW_RESULT:
3704
3722
        /*
3705
3723
          The row comparator was created at the beginning but only DATETIME
3708
3726
        */
3709
3727
        ((in_row*)array)->tmp.store_value(args[0]);
3710
3728
        break;
 
3729
 
3711
3730
      case DECIMAL_RESULT:
3712
3731
        array= new in_decimal(arg_count - 1);
3713
3732
        break;
3714
 
      default:
3715
 
        assert(0);
3716
 
        return;
3717
3733
      }
3718
3734
    }
 
3735
 
3719
3736
    if (array && !(session->is_fatal_error))            // If not EOM
3720
3737
    {
3721
3738
      uint32_t j=0;
3722
3739
      for (uint32_t arg_num=1 ; arg_num < arg_count ; arg_num++)
3723
3740
      {
3724
 
        if (!args[arg_num]->null_value)                 // Skip NULL values
 
3741
        if (!args[arg_num]->null_value)                 // Skip NULL values
3725
3742
        {
3726
3743
          array->set(j,args[arg_num]);
3727
 
          j++;
 
3744
          j++;
3728
3745
        }
3729
 
        else
3730
 
          have_null= 1;
 
3746
        else
 
3747
          have_null= 1;
3731
3748
      }
3732
3749
      if ((array->used_count= j))
3733
 
        array->sort();
 
3750
        array->sort();
3734
3751
    }
3735
3752
  }
3736
3753
  else