← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/sum.cc

  • Committer: David Shrewsbury
  • Date: 2010-11-15 15:29:16 UTC
  • mto: (1932.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1933.
  • Revision ID: shrewsbury.dave@gmail.com-20101115152916-cowsgsfm3sibys30
Move transaction_reader from drizzled/message to transaction_log plugin; also pulled transaction_reader file operations out into separate class.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/sum.cc
33
33
#include <drizzled/item/sum.h>
34
34
#include <drizzled/field/decimal.h>
35
35
#include <drizzled/field/double.h>
36
 
#include <drizzled/field/int64.h>
 
36
#include <drizzled/field/int64_t.h>
37
37
#include <drizzled/field/date.h>
38
38
#include <drizzled/field/datetime.h>
39
39
 
40
 
#include <drizzled/type/decimal.h>
41
 
 
42
40
#include "drizzled/internal/m_string.h"
43
41
 
44
42
#include <algorithm>
48
46
namespace drizzled
49
47
{
50
48
 
 
49
extern my_decimal decimal_zero;
51
50
extern plugin::StorageEngine *heap_engine;
52
51
 
53
52
/**
412
411
  if (arg_count <= 2)
413
412
    args=tmp_args;
414
413
  else
415
 
    if (!(args= (Item**) session->getMemRoot()->allocate(sizeof(Item*)*arg_count)))
 
414
    if (!(args= (Item**) session->alloc(sizeof(Item*)*arg_count)))
416
415
      return;
417
416
  memcpy(args, item->args, sizeof(Item*)*arg_count);
418
417
}
420
419
 
421
420
void Item_sum::mark_as_sum_func()
422
421
{
423
 
  Select_Lex *cur_select= getSession().getLex()->current_select;
 
422
  Select_Lex *cur_select= current_session->lex->current_select;
424
423
  cur_select->n_sum_items++;
425
424
  cur_select->with_sum_func= 1;
426
425
  with_sum_func= 1;
509
508
                                  Table *table,
510
509
                                  uint32_t convert_blob_length)
511
510
{
512
 
  Field *field= NULL;
513
 
 
 
511
  Field *field;
514
512
  switch (result_type()) {
515
513
  case REAL_RESULT:
516
514
    field= new Field_double(max_length, maybe_null, name, decimals, true);
517
515
    break;
518
 
 
519
516
  case INT_RESULT:
520
 
    field= new field::Int64(max_length, maybe_null, name, unsigned_flag);
 
517
    field= new Field_int64_t(max_length, maybe_null, name, unsigned_flag);
521
518
    break;
522
 
 
523
519
  case STRING_RESULT:
524
520
    if (max_length/collation.collation->mbmaxlen <= 255 ||
525
521
        convert_blob_length > Field_varstring::MAX_SIZE ||
526
522
        !convert_blob_length)
527
 
    {
528
523
      return make_string_field(table);
529
 
    }
530
524
 
531
525
    table->setVariableWidth();
532
526
    field= new Field_varstring(convert_blob_length, maybe_null,
533
527
                               name, collation.collation);
534
528
    break;
535
 
 
536
529
  case DECIMAL_RESULT:
537
530
    field= new Field_decimal(max_length, maybe_null, name,
538
 
                             decimals, unsigned_flag);
 
531
                                 decimals, unsigned_flag);
539
532
    break;
540
 
 
541
533
  case ROW_RESULT:
 
534
  default:
542
535
    // This case should never be choosen
543
536
    assert(0);
544
537
    return 0;
545
538
  }
546
 
 
547
539
  if (field)
548
540
    field->init(table);
549
 
 
550
541
  return field;
551
542
}
552
543
 
584
575
}
585
576
 
586
577
 
587
 
type::Decimal *Item_sum_num::val_decimal(type::Decimal *decimal_value)
 
578
my_decimal *Item_sum_num::val_decimal(my_decimal *decimal_value)
588
579
{
589
580
  return val_decimal_from_real(decimal_value);
590
581
}
597
588
}
598
589
 
599
590
 
600
 
type::Decimal *Item_sum_int::val_decimal(type::Decimal *decimal_value)
 
591
my_decimal *Item_sum_int::val_decimal(my_decimal *decimal_value)
601
592
{
602
593
  return val_decimal_from_int(decimal_value);
603
594
}
644
635
    sum_int= item->sum_int;
645
636
    break;
646
637
  case DECIMAL_RESULT:
647
 
    class_decimal2decimal(&item->sum_dec, &sum_dec);
 
638
    my_decimal2decimal(&item->sum_dec, &sum_dec);
648
639
    break;
649
640
  case REAL_RESULT:
650
641
    sum= item->sum;
656
647
    */
657
648
    break;
658
649
  case ROW_RESULT:
 
650
  default:
659
651
    assert(0);
660
652
  }
661
653
  collation.set(item->collation);
684
676
    break;
685
677
  case DECIMAL_RESULT:
686
678
    max_length= item->max_length;
687
 
    sum_dec.set_zero();
 
679
    my_decimal_set_zero(&sum_dec);
688
680
    break;
689
681
  case REAL_RESULT:
690
682
    max_length= float_length(decimals);
694
686
    max_length= item->max_length;
695
687
    break;
696
688
  case ROW_RESULT:
 
689
  default:
697
690
    assert(0);
698
691
  };
699
692
  /* MIN/MAX can return NULL for empty set indepedent of the used column */
724
717
  {
725
718
    field= ((Item_field*) args[0])->field;
726
719
 
727
 
    if ((field= create_tmp_field_from_field(&getSession(), field, name, table,
 
720
    if ((field= create_tmp_field_from_field(current_session, field, name, table,
728
721
                                            NULL, convert_blob_length)))
729
722
      field->flags&= ~NOT_NULL_FLAG;
730
723
    return field;
745
738
  default:
746
739
    return Item_sum::create_tmp_field(group, table, convert_blob_length);
747
740
  }
748
 
 
749
741
  if (field)
750
742
    field->init(table);
751
 
 
752
743
  return field;
753
744
}
754
745
 
768
759
  /* TODO: check if the following assignments are really needed */
769
760
  if (hybrid_type == DECIMAL_RESULT)
770
761
  {
771
 
    class_decimal2decimal(item->dec_buffs, dec_buffs);
772
 
    class_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
 
762
    my_decimal2decimal(item->dec_buffs, dec_buffs);
 
763
    my_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
773
764
  }
774
765
  else
775
766
    sum= item->sum;
787
778
  if (hybrid_type == DECIMAL_RESULT)
788
779
  {
789
780
    curr_dec_buff= 0;
790
 
    dec_buffs->set_zero();
 
781
    my_decimal_set_zero(dec_buffs);
791
782
  }
792
783
  else
793
784
    sum= 0.0;
807
798
    break;
808
799
  case INT_RESULT:
809
800
  case DECIMAL_RESULT:
810
 
    {
811
 
      /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
812
 
      int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
813
 
      max_length= class_decimal_precision_to_length(precision, decimals,
814
 
                                                 unsigned_flag);
815
 
      curr_dec_buff= 0;
816
 
      hybrid_type= DECIMAL_RESULT;
817
 
      dec_buffs->set_zero();
818
 
      break;
819
 
    }
 
801
  {
 
802
    /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
 
803
    int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
 
804
    max_length= my_decimal_precision_to_length(precision, decimals,
 
805
                                               unsigned_flag);
 
806
    curr_dec_buff= 0;
 
807
    hybrid_type= DECIMAL_RESULT;
 
808
    my_decimal_set_zero(dec_buffs);
 
809
    break;
 
810
  }
820
811
  case ROW_RESULT:
 
812
  default:
821
813
    assert(0);
822
814
  }
 
815
  return;
823
816
}
824
817
 
825
818
 
827
820
{
828
821
  if (hybrid_type == DECIMAL_RESULT)
829
822
  {
830
 
    type::Decimal value, *val= args[0]->val_decimal(&value);
 
823
    my_decimal value, *val= args[0]->val_decimal(&value);
831
824
    if (!args[0]->null_value)
832
825
    {
833
 
      class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
 
826
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
834
827
                     val, dec_buffs + curr_dec_buff);
835
828
      curr_dec_buff^= 1;
836
829
      null_value= 0;
852
845
  if (hybrid_type == DECIMAL_RESULT)
853
846
  {
854
847
    int64_t result;
855
 
    (dec_buffs + curr_dec_buff)->val_int32(E_DEC_FATAL_ERROR, unsigned_flag, &result);
 
848
    my_decimal2int(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, unsigned_flag,
 
849
                   &result);
856
850
    return result;
857
851
  }
858
852
  return (int64_t) rint(val_real());
863
857
{
864
858
  assert(fixed == 1);
865
859
  if (hybrid_type == DECIMAL_RESULT)
866
 
    class_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
 
860
    my_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
867
861
  return sum;
868
862
}
869
863
 
876
870
}
877
871
 
878
872
 
879
 
type::Decimal *Item_sum_sum::val_decimal(type::Decimal *val)
 
873
my_decimal *Item_sum_sum::val_decimal(my_decimal *val)
880
874
{
881
875
  if (hybrid_type == DECIMAL_RESULT)
882
876
    return (dec_buffs + curr_dec_buff);
939
933
 
940
934
  virtual void div(Hybrid_type *val, uint64_t u) const
941
935
  {
942
 
    int2_class_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
 
936
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
943
937
    val->used_dec_buf_no= 0;
944
938
    val->traits= Hybrid_type_traits_decimal::instance();
945
939
    val->traits->div(val, u);
972
966
    table_field_type= DRIZZLE_TYPE_DOUBLE;
973
967
    break;
974
968
  case INT_RESULT:
975
 
    /*
976
 
      Preserving int8, int16, int32 field types gives ~10% performance boost
977
 
      as the size of result tree becomes significantly smaller.
978
 
      Another speed up we gain by using int64_t for intermediate
979
 
      calculations. The range of int64 is enough to hold sum 2^32 distinct
980
 
      integers each <= 2^32.
981
 
    */
982
 
    if (table_field_type == DRIZZLE_TYPE_LONG)
983
 
    {
984
 
      val.traits= Hybrid_type_traits_fast_decimal::instance();
985
 
      break;
986
 
    }
987
 
    table_field_type= DRIZZLE_TYPE_LONGLONG;
988
 
    /* fallthrough */
 
969
  /*
 
970
    Preserving int8, int16, int32 field types gives ~10% performance boost
 
971
    as the size of result tree becomes significantly smaller.
 
972
    Another speed up we gain by using int64_t for intermediate
 
973
    calculations. The range of int64 is enough to hold sum 2^32 distinct
 
974
    integers each <= 2^32.
 
975
  */
 
976
  if (table_field_type == DRIZZLE_TYPE_LONG)
 
977
  {
 
978
    val.traits= Hybrid_type_traits_fast_decimal::instance();
 
979
    break;
 
980
  }
 
981
  table_field_type= DRIZZLE_TYPE_LONGLONG;
 
982
  /* fallthrough */
989
983
  case DECIMAL_RESULT:
990
984
    val.traits= Hybrid_type_traits_decimal::instance();
991
985
    if (table_field_type != DRIZZLE_TYPE_LONGLONG)
992
986
      table_field_type= DRIZZLE_TYPE_DECIMAL;
993
987
    break;
994
988
  case ROW_RESULT:
 
989
  default:
995
990
    assert(0);
996
991
  }
997
 
 
998
992
  val.traits->fix_length_and_dec(this, args[0]);
999
993
}
1000
994
 
1133
1127
}
1134
1128
 
1135
1129
 
1136
 
type::Decimal *Item_sum_distinct::val_decimal(type::Decimal *to)
 
1130
my_decimal *Item_sum_distinct::val_decimal(my_decimal *to)
1137
1131
{
1138
1132
  calculate_val_and_count();
1139
1133
  if (null_value)
1165
1159
Item_sum_avg_distinct::fix_length_and_dec()
1166
1160
{
1167
1161
  Item_sum_distinct::fix_length_and_dec();
1168
 
  prec_increment= getSession().variables.div_precincrement;
 
1162
  prec_increment= current_session->variables.div_precincrement;
1169
1163
  /*
1170
1164
    AVG() will divide val by count. We need to reserve digits
1171
1165
    after decimal point as the result can be fractional.
1228
1222
{
1229
1223
  Item_sum_sum::fix_length_and_dec();
1230
1224
  maybe_null=null_value=1;
1231
 
  prec_increment= getSession().variables.div_precincrement;
1232
 
 
 
1225
  prec_increment= current_session->variables.div_precincrement;
1233
1226
  if (hybrid_type == DECIMAL_RESULT)
1234
1227
  {
1235
1228
    int precision= args[0]->decimal_precision() + prec_increment;
1236
1229
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
1237
 
    max_length= class_decimal_precision_to_length(precision, decimals,
 
1230
    max_length= my_decimal_precision_to_length(precision, decimals,
1238
1231
                                               unsigned_flag);
1239
1232
    f_precision= min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
1240
1233
    f_scale=  args[0]->decimals;
1241
 
    dec_bin_size= class_decimal_get_binary_size(f_precision, f_scale);
 
1234
    dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
1242
1235
  }
1243
1236
  else {
1244
1237
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) NOT_FIXED_DEC);
1314
1307
}
1315
1308
 
1316
1309
 
1317
 
type::Decimal *Item_sum_avg::val_decimal(type::Decimal *val)
 
1310
my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
1318
1311
{
1319
 
  type::Decimal sum_buff, cnt;
1320
 
  const type::Decimal *sum_dec;
 
1312
  my_decimal sum_buff, cnt;
 
1313
  const my_decimal *sum_dec;
1321
1314
  assert(fixed == 1);
1322
1315
  if (!count)
1323
1316
  {
1333
1326
    return val_decimal_from_real(val);
1334
1327
 
1335
1328
  sum_dec= dec_buffs + curr_dec_buff;
1336
 
  int2_class_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
1337
 
  class_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
 
1329
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
 
1330
  my_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
1338
1331
  return val;
1339
1332
}
1340
1333
 
1426
1419
void Item_sum_variance::fix_length_and_dec()
1427
1420
{
1428
1421
  maybe_null= null_value= 1;
1429
 
  prec_increment= getSession().variables.div_precincrement;
 
1422
  prec_increment= current_session->variables.div_precincrement;
1430
1423
 
1431
1424
  /*
1432
1425
    According to the SQL2003 standard (Part 2, Foundations; sec 10.9,
1443
1436
    break;
1444
1437
  case INT_RESULT:
1445
1438
  case DECIMAL_RESULT:
1446
 
    {
1447
 
      int precision= args[0]->decimal_precision()*2 + prec_increment;
1448
 
      decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
1449
 
      max_length= class_decimal_precision_to_length(precision, decimals,
1450
 
                                                 unsigned_flag);
 
1439
  {
 
1440
    int precision= args[0]->decimal_precision()*2 + prec_increment;
 
1441
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
 
1442
    max_length= my_decimal_precision_to_length(precision, decimals,
 
1443
                                               unsigned_flag);
1451
1444
 
1452
 
      break;
1453
 
    }
 
1445
    break;
 
1446
  }
1454
1447
  case ROW_RESULT:
 
1448
  default:
1455
1449
    assert(0);
1456
1450
  }
 
1451
  return;
1457
1452
}
1458
1453
 
1459
1454
 
1542
1537
}
1543
1538
 
1544
1539
 
1545
 
type::Decimal *Item_sum_variance::val_decimal(type::Decimal *dec_buf)
 
1540
my_decimal *Item_sum_variance::val_decimal(my_decimal *dec_buf)
1546
1541
{
1547
1542
  assert(fixed == 1);
1548
1543
  return val_decimal_from_real(dec_buf);
1606
1601
    sum_int= 0;
1607
1602
    break;
1608
1603
  case DECIMAL_RESULT:
1609
 
    sum_dec.set_zero();
 
1604
    my_decimal_set_zero(&sum_dec);
1610
1605
    break;
1611
1606
  case REAL_RESULT:
1612
1607
    sum= 0.0;
1622
1617
  assert(fixed == 1);
1623
1618
  if (null_value)
1624
1619
    return 0.0;
1625
 
 
1626
1620
  switch (hybrid_type) {
1627
1621
  case STRING_RESULT:
1628
 
    {
1629
 
      char *end_not_used;
1630
 
      int err_not_used;
1631
 
      String *res;  res=val_str(&str_value);
1632
 
      return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
1633
 
                               &end_not_used, &err_not_used) : 0.0);
1634
 
    }
 
1622
  {
 
1623
    char *end_not_used;
 
1624
    int err_not_used;
 
1625
    String *res;  res=val_str(&str_value);
 
1626
    return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
 
1627
                             &end_not_used, &err_not_used) : 0.0);
 
1628
  }
1635
1629
  case INT_RESULT:
1636
1630
    return (double) sum_int;
1637
1631
  case DECIMAL_RESULT:
1638
 
    class_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
 
1632
    my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
1639
1633
    return sum;
1640
1634
  case REAL_RESULT:
1641
1635
    return sum;
1642
1636
  case ROW_RESULT:
 
1637
  default:
1643
1638
    // This case should never be choosen
1644
 
    break;
 
1639
    assert(0);
 
1640
    return 0;
1645
1641
  }
1646
 
 
1647
 
  assert(0);
1648
 
  return 0;
1649
1642
}
1650
1643
 
1651
1644
int64_t Item_sum_hybrid::val_int()
1659
1652
  case DECIMAL_RESULT:
1660
1653
  {
1661
1654
    int64_t result;
1662
 
    sum_dec.val_int32(E_DEC_FATAL_ERROR, unsigned_flag, &result);
 
1655
    my_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
1663
1656
    return sum_int;
1664
1657
  }
1665
1658
  default:
1668
1661
}
1669
1662
 
1670
1663
 
1671
 
type::Decimal *Item_sum_hybrid::val_decimal(type::Decimal *val)
 
1664
my_decimal *Item_sum_hybrid::val_decimal(my_decimal *val)
1672
1665
{
1673
1666
  assert(fixed == 1);
1674
1667
  if (null_value)
1675
1668
    return 0;
1676
 
 
1677
1669
  switch (hybrid_type) {
1678
1670
  case STRING_RESULT:
1679
 
    val->store(E_DEC_FATAL_ERROR, &value);
 
1671
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
1680
1672
    break;
1681
1673
  case REAL_RESULT:
1682
 
    double2_class_decimal(E_DEC_FATAL_ERROR, sum, val);
 
1674
    double2my_decimal(E_DEC_FATAL_ERROR, sum, val);
1683
1675
    break;
1684
1676
  case DECIMAL_RESULT:
1685
1677
    val= &sum_dec;
1686
1678
    break;
1687
1679
  case INT_RESULT:
1688
 
    int2_class_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
 
1680
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
1689
1681
    break;
1690
1682
  case ROW_RESULT:
 
1683
  default:
1691
1684
    // This case should never be choosen
1692
1685
    assert(0);
1693
1686
    break;
1694
1687
  }
1695
 
 
1696
1688
  return val;                                   // Keep compiler happy
1697
1689
}
1698
1690
 
1703
1695
  assert(fixed == 1);
1704
1696
  if (null_value)
1705
1697
    return 0;
1706
 
 
1707
1698
  switch (hybrid_type) {
1708
1699
  case STRING_RESULT:
1709
1700
    return &value;
1711
1702
    str->set_real(sum,decimals, &my_charset_bin);
1712
1703
    break;
1713
1704
  case DECIMAL_RESULT:
1714
 
    class_decimal2string(&sum_dec, 0, str);
 
1705
    my_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
1715
1706
    return str;
1716
1707
  case INT_RESULT:
1717
1708
    str->set_int(sum_int, unsigned_flag, &my_charset_bin);
1719
1710
  case ROW_RESULT:
1720
1711
  default:
1721
1712
    // This case should never be choosen
 
1713
    assert(0);
1722
1714
    break;
1723
1715
  }
1724
 
 
1725
1716
  return str;                                   // Keep compiler happy
1726
1717
}
1727
1718
 
1759
1750
{
1760
1751
  switch (hybrid_type) {
1761
1752
  case STRING_RESULT:
 
1753
  {
 
1754
    String *result=args[0]->val_str(&tmp_value);
 
1755
    if (!args[0]->null_value &&
 
1756
        (null_value || sortcmp(&value,result,collation.collation) > 0))
1762
1757
    {
1763
 
      String *result=args[0]->val_str(&tmp_value);
1764
 
      if (!args[0]->null_value &&
1765
 
          (null_value || sortcmp(&value,result,collation.collation) > 0))
1766
 
      {
1767
 
        value.copy(*result);
1768
 
        null_value=0;
1769
 
      }
 
1758
      value.copy(*result);
 
1759
      null_value=0;
1770
1760
    }
1771
 
    break;
 
1761
  }
 
1762
  break;
1772
1763
  case INT_RESULT:
 
1764
  {
 
1765
    int64_t nr=args[0]->val_int();
 
1766
    if (!args[0]->null_value && (null_value ||
 
1767
                                 (unsigned_flag &&
 
1768
                                  (uint64_t) nr < (uint64_t) sum_int) ||
 
1769
                                 (!unsigned_flag && nr < sum_int)))
1773
1770
    {
1774
 
      int64_t nr=args[0]->val_int();
1775
 
      if (!args[0]->null_value && (null_value ||
1776
 
                                   (unsigned_flag &&
1777
 
                                    (uint64_t) nr < (uint64_t) sum_int) ||
1778
 
                                   (!unsigned_flag && nr < sum_int)))
1779
 
      {
1780
 
        sum_int=nr;
1781
 
        null_value=0;
1782
 
      }
 
1771
      sum_int=nr;
 
1772
      null_value=0;
1783
1773
    }
1784
 
    break;
 
1774
  }
 
1775
  break;
1785
1776
  case DECIMAL_RESULT:
 
1777
  {
 
1778
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1779
    if (!args[0]->null_value &&
 
1780
        (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
1786
1781
    {
1787
 
      type::Decimal value_buff, *val= args[0]->val_decimal(&value_buff);
1788
 
      if (!args[0]->null_value &&
1789
 
          (null_value || (class_decimal_cmp(&sum_dec, val) > 0)))
1790
 
      {
1791
 
        class_decimal2decimal(val, &sum_dec);
1792
 
        null_value= 0;
1793
 
      }
 
1782
      my_decimal2decimal(val, &sum_dec);
 
1783
      null_value= 0;
1794
1784
    }
1795
 
    break;
 
1785
  }
 
1786
  break;
1796
1787
  case REAL_RESULT:
 
1788
  {
 
1789
    double nr= args[0]->val_real();
 
1790
    if (!args[0]->null_value && (null_value || nr < sum))
1797
1791
    {
1798
 
      double nr= args[0]->val_real();
1799
 
      if (!args[0]->null_value && (null_value || nr < sum))
1800
 
      {
1801
 
        sum=nr;
1802
 
        null_value=0;
1803
 
      }
 
1792
      sum=nr;
 
1793
      null_value=0;
1804
1794
    }
1805
 
    break;
 
1795
  }
 
1796
  break;
1806
1797
  case ROW_RESULT:
 
1798
  default:
1807
1799
    // This case should never be choosen
1808
1800
    assert(0);
1809
1801
    break;
1822
1814
{
1823
1815
  switch (hybrid_type) {
1824
1816
  case STRING_RESULT:
 
1817
  {
 
1818
    String *result=args[0]->val_str(&tmp_value);
 
1819
    if (!args[0]->null_value &&
 
1820
        (null_value || sortcmp(&value,result,collation.collation) < 0))
1825
1821
    {
1826
 
      String *result=args[0]->val_str(&tmp_value);
1827
 
      if (!args[0]->null_value &&
1828
 
          (null_value || sortcmp(&value,result,collation.collation) < 0))
1829
 
      {
1830
 
        value.copy(*result);
1831
 
        null_value=0;
1832
 
      }
 
1822
      value.copy(*result);
 
1823
      null_value=0;
1833
1824
    }
1834
 
    break;
 
1825
  }
 
1826
  break;
1835
1827
  case INT_RESULT:
 
1828
  {
 
1829
    int64_t nr=args[0]->val_int();
 
1830
    if (!args[0]->null_value && (null_value ||
 
1831
                                 (unsigned_flag &&
 
1832
                                  (uint64_t) nr > (uint64_t) sum_int) ||
 
1833
                                 (!unsigned_flag && nr > sum_int)))
1836
1834
    {
1837
 
      int64_t nr=args[0]->val_int();
1838
 
      if (!args[0]->null_value && (null_value ||
1839
 
                                   (unsigned_flag &&
1840
 
                                    (uint64_t) nr > (uint64_t) sum_int) ||
1841
 
                                   (!unsigned_flag && nr > sum_int)))
1842
 
      {
1843
 
        sum_int=nr;
1844
 
        null_value=0;
1845
 
      }
 
1835
      sum_int=nr;
 
1836
      null_value=0;
1846
1837
    }
1847
 
    break;
 
1838
  }
 
1839
  break;
1848
1840
  case DECIMAL_RESULT:
 
1841
  {
 
1842
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1843
    if (!args[0]->null_value &&
 
1844
        (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
1849
1845
    {
1850
 
      type::Decimal value_buff, *val= args[0]->val_decimal(&value_buff);
1851
 
      if (!args[0]->null_value &&
1852
 
          (null_value || (class_decimal_cmp(val, &sum_dec) > 0)))
1853
 
      {
1854
 
        class_decimal2decimal(val, &sum_dec);
1855
 
        null_value= 0;
1856
 
      }
 
1846
      my_decimal2decimal(val, &sum_dec);
 
1847
      null_value= 0;
1857
1848
    }
1858
 
    break;
 
1849
  }
 
1850
  break;
1859
1851
  case REAL_RESULT:
 
1852
  {
 
1853
    double nr= args[0]->val_real();
 
1854
    if (!args[0]->null_value && (null_value || nr > sum))
1860
1855
    {
1861
 
      double nr= args[0]->val_real();
1862
 
      if (!args[0]->null_value && (null_value || nr > sum))
1863
 
      {
1864
 
        sum=nr;
1865
 
        null_value=0;
1866
 
      }
 
1856
      sum=nr;
 
1857
      null_value=0;
1867
1858
    }
1868
 
    break;
 
1859
  }
 
1860
  break;
1869
1861
  case ROW_RESULT:
 
1862
  default:
1870
1863
    // This case should never be choosen
1871
1864
    assert(0);
1872
1865
    break;
1873
1866
  }
1874
 
 
1875
1867
  return 0;
1876
1868
}
1877
1869
 
1959
1951
{
1960
1952
  switch(hybrid_type) {
1961
1953
  case STRING_RESULT:
1962
 
    {
1963
 
      char buff[MAX_FIELD_WIDTH];
1964
 
      String tmp(buff,sizeof(buff),result_field->charset()),*res;
1965
 
 
1966
 
      res=args[0]->val_str(&tmp);
1967
 
      if (args[0]->null_value)
1968
 
      {
 
1954
  {
 
1955
    char buff[MAX_FIELD_WIDTH];
 
1956
    String tmp(buff,sizeof(buff),result_field->charset()),*res;
 
1957
 
 
1958
    res=args[0]->val_str(&tmp);
 
1959
    if (args[0]->null_value)
 
1960
    {
 
1961
      result_field->set_null();
 
1962
      result_field->reset();
 
1963
    }
 
1964
    else
 
1965
    {
 
1966
      result_field->set_notnull();
 
1967
      result_field->store(res->ptr(),res->length(),tmp.charset());
 
1968
    }
 
1969
    break;
 
1970
  }
 
1971
  case INT_RESULT:
 
1972
  {
 
1973
    int64_t nr=args[0]->val_int();
 
1974
 
 
1975
    if (maybe_null)
 
1976
    {
 
1977
      if (args[0]->null_value)
 
1978
      {
 
1979
        nr=0;
 
1980
        result_field->set_null();
 
1981
      }
 
1982
      else
 
1983
        result_field->set_notnull();
 
1984
    }
 
1985
    result_field->store(nr, unsigned_flag);
 
1986
    break;
 
1987
  }
 
1988
  case REAL_RESULT:
 
1989
  {
 
1990
    double nr= args[0]->val_real();
 
1991
 
 
1992
    if (maybe_null)
 
1993
    {
 
1994
      if (args[0]->null_value)
 
1995
      {
 
1996
        nr=0.0;
 
1997
        result_field->set_null();
 
1998
      }
 
1999
      else
 
2000
        result_field->set_notnull();
 
2001
    }
 
2002
    result_field->store(nr);
 
2003
    break;
 
2004
  }
 
2005
  case DECIMAL_RESULT:
 
2006
  {
 
2007
    my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
 
2008
 
 
2009
    if (maybe_null)
 
2010
    {
 
2011
      if (args[0]->null_value)
1969
2012
        result_field->set_null();
1970
 
        result_field->reset();
1971
 
      }
1972
2013
      else
1973
 
      {
1974
2014
        result_field->set_notnull();
1975
 
        result_field->store(res->ptr(),res->length(),tmp.charset());
1976
 
      }
1977
 
      break;
1978
 
    }
1979
 
  case INT_RESULT:
1980
 
    {
1981
 
      int64_t nr=args[0]->val_int();
1982
 
 
1983
 
      if (maybe_null)
1984
 
      {
1985
 
        if (args[0]->null_value)
1986
 
        {
1987
 
          nr=0;
1988
 
          result_field->set_null();
1989
 
        }
1990
 
        else
1991
 
          result_field->set_notnull();
1992
 
      }
1993
 
      result_field->store(nr, unsigned_flag);
1994
 
      break;
1995
 
    }
1996
 
  case REAL_RESULT:
1997
 
    {
1998
 
      double nr= args[0]->val_real();
1999
 
 
2000
 
      if (maybe_null)
2001
 
      {
2002
 
        if (args[0]->null_value)
2003
 
        {
2004
 
          nr=0.0;
2005
 
          result_field->set_null();
2006
 
        }
2007
 
        else
2008
 
          result_field->set_notnull();
2009
 
      }
2010
 
      result_field->store(nr);
2011
 
      break;
2012
 
    }
2013
 
  case DECIMAL_RESULT:
2014
 
    {
2015
 
      type::Decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
2016
 
 
2017
 
      if (maybe_null)
2018
 
      {
2019
 
        if (args[0]->null_value)
2020
 
          result_field->set_null();
2021
 
        else
2022
 
          result_field->set_notnull();
2023
 
      }
2024
 
      /*
2025
 
        We must store zero in the field as we will use the field value in
2026
 
        add()
2027
 
      */
2028
 
      if (!arg_dec)                               // Null
2029
 
        arg_dec= &decimal_zero;
2030
 
      result_field->store_decimal(arg_dec);
2031
 
      break;
2032
 
    }
 
2015
    }
 
2016
    /*
 
2017
      We must store zero in the field as we will use the field value in
 
2018
      add()
 
2019
    */
 
2020
    if (!arg_dec)                               // Null
 
2021
      arg_dec= &decimal_zero;
 
2022
    result_field->store_decimal(arg_dec);
 
2023
    break;
 
2024
  }
2033
2025
  case ROW_RESULT:
 
2026
  default:
2034
2027
    assert(0);
2035
2028
  }
2036
2029
}
2040
2033
{
2041
2034
  if (hybrid_type == DECIMAL_RESULT)
2042
2035
  {
2043
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2036
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2044
2037
    if (!arg_val)                               // Null
2045
2038
      arg_val= &decimal_zero;
2046
2039
    result_field->store_decimal(arg_val);
2075
2068
  if (hybrid_type == DECIMAL_RESULT)
2076
2069
  {
2077
2070
    int64_t tmp;
2078
 
    type::Decimal value, *arg_dec= args[0]->val_decimal(&value);
 
2071
    my_decimal value, *arg_dec= args[0]->val_decimal(&value);
2079
2072
    if (args[0]->null_value)
2080
2073
    {
2081
2074
      arg_dec= &decimal_zero;
2083
2076
    }
2084
2077
    else
2085
2078
      tmp= 1;
2086
 
    arg_dec->val_binary(E_DEC_FATAL_ERROR, res, f_precision, f_scale);
 
2079
    my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec, res, f_precision, f_scale);
2087
2080
    res+= dec_bin_size;
2088
2081
    int8store(res, tmp);
2089
2082
  }
2127
2120
{
2128
2121
  if (hybrid_type == DECIMAL_RESULT)
2129
2122
  {
2130
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2123
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2131
2124
    if (!args[0]->null_value)
2132
2125
    {
2133
2126
      if (!result_field->is_null())
2134
2127
      {
2135
 
        type::Decimal field_value,
 
2128
        my_decimal field_value,
2136
2129
                   *field_val= result_field->val_decimal(&field_value);
2137
 
        class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
 
2130
        my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
2138
2131
        result_field->store_decimal(dec_buffs);
2139
2132
      }
2140
2133
      else
2179
2172
  unsigned char *res=result_field->ptr;
2180
2173
  if (hybrid_type == DECIMAL_RESULT)
2181
2174
  {
2182
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2175
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2183
2176
    if (!args[0]->null_value)
2184
2177
    {
2185
 
      binary2_class_decimal(E_DEC_FATAL_ERROR, res,
 
2178
      binary2my_decimal(E_DEC_FATAL_ERROR, res,
2186
2179
                        dec_buffs + 1, f_precision, f_scale);
2187
2180
      field_count= sint8korr(res + dec_bin_size);
2188
 
      class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, dec_buffs + 1);
2189
 
      dec_buffs->val_binary(E_DEC_FATAL_ERROR, res, f_precision, f_scale);
 
2181
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, dec_buffs + 1);
 
2182
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_buffs,
 
2183
                        res, f_precision, f_scale);
2190
2184
      res+= dec_bin_size;
2191
2185
      field_count++;
2192
2186
      int8store(res, field_count);
2224
2218
  case DECIMAL_RESULT:
2225
2219
    min_max_update_decimal_field();
2226
2220
    break;
2227
 
  case REAL_RESULT:
2228
 
  case ROW_RESULT:
 
2221
  default:
2229
2222
    min_max_update_real_field();
2230
2223
  }
2231
2224
}
2238
2231
 
2239
2232
  if (!args[0]->null_value)
2240
2233
  {
2241
 
    result_field->val_str_internal(&tmp_value);
 
2234
    result_field->val_str(&tmp_value);
2242
2235
 
2243
2236
    if (result_field->is_null() ||
2244
2237
        (cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
2304
2297
Item_sum_hybrid::min_max_update_decimal_field()
2305
2298
{
2306
2299
  /* TODO: optimize: do not get result_field in case of args[0] is NULL */
2307
 
  type::Decimal old_val, nr_val;
2308
 
  const type::Decimal *old_nr= result_field->val_decimal(&old_val);
2309
 
  const type::Decimal *nr= args[0]->val_decimal(&nr_val);
 
2300
  my_decimal old_val, nr_val;
 
2301
  const my_decimal *old_nr= result_field->val_decimal(&old_val);
 
2302
  const my_decimal *nr= args[0]->val_decimal(&nr_val);
2310
2303
  if (!args[0]->null_value)
2311
2304
  {
2312
2305
    if (result_field->is_null(0))
2313
2306
      old_nr=nr;
2314
2307
    else
2315
2308
    {
2316
 
      bool res= class_decimal_cmp(old_nr, nr) > 0;
 
2309
      bool res= my_decimal_cmp(old_nr, nr) > 0;
2317
2310
      /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
2318
2311
      if ((cmp_sign > 0) ^ (!res))
2319
2312
        old_nr=nr;
2370
2363
}
2371
2364
 
2372
2365
 
2373
 
type::Decimal *Item_avg_field::val_decimal(type::Decimal *dec_buf)
 
2366
my_decimal *Item_avg_field::val_decimal(my_decimal *dec_buf)
2374
2367
{
2375
2368
  // fix_fields() never calls for this Item
2376
2369
  if (hybrid_type == REAL_RESULT)
2380
2373
  if ((null_value= !count))
2381
2374
    return 0;
2382
2375
 
2383
 
  type::Decimal dec_count, dec_field;
2384
 
  binary2_class_decimal(E_DEC_FATAL_ERROR,
 
2376
  my_decimal dec_count, dec_field;
 
2377
  binary2my_decimal(E_DEC_FATAL_ERROR,
2385
2378
                    field->ptr, &dec_field, f_precision, f_scale);
2386
 
  int2_class_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
2387
 
  class_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
 
2379
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
 
2380
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
2388
2381
                 &dec_field, &dec_count, prec_increment);
2389
2382
  return dec_buf;
2390
2383
}
2415
2408
}
2416
2409
 
2417
2410
 
2418
 
type::Decimal *Item_std_field::val_decimal(type::Decimal *dec_buf)
 
2411
my_decimal *Item_std_field::val_decimal(my_decimal *dec_buf)
2419
2412
{
2420
2413
  /*
2421
2414
    We can't call val_decimal_from_real() for DECIMAL_RESULT as
2422
2415
    Item_variance_field::val_real() would cause an infinite loop
2423
2416
  */
2424
 
  type::Decimal tmp_dec, *dec;
 
2417
  my_decimal tmp_dec, *dec;
2425
2418
  double nr;
2426
2419
  if (hybrid_type == REAL_RESULT)
2427
2420
    return val_decimal_from_real(dec_buf);
2429
2422
  dec= Item_variance_field::val_decimal(dec_buf);
2430
2423
  if (!dec)
2431
2424
    return 0;
2432
 
  class_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
 
2425
  my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
2433
2426
  assert(nr >= 0.0);
2434
2427
  nr= sqrt(nr);
2435
 
  double2_class_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
2436
 
  class_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, false, dec_buf);
 
2428
  double2my_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
 
2429
  my_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, false, dec_buf);
2437
2430
  return dec_buf;
2438
2431
}
2439
2432
 
2667
2660
        uint32_t *length;
2668
2661
        compare_key= (qsort_cmp2) composite_key_cmp;
2669
2662
        cmp_arg= (void*) this;
2670
 
        field_lengths= (uint32_t*) session->getMemRoot()->allocate(table->getShare()->sizeFields() * sizeof(uint32_t));
 
2663
        field_lengths= (uint32_t*) session->alloc(table->getShare()->sizeFields() * sizeof(uint32_t));
2671
2664
        for (tree_key_length= 0, length= field_lengths, field= table->getFields();
2672
2665
             field < field_end; ++field, ++length)
2673
2666
        {
2721
2714
  if (always_null)
2722
2715
    return 0;
2723
2716
  copy_fields(tmp_table_param);
2724
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
2725
 
    return true;
 
2717
  copy_funcs(tmp_table_param->items_to_copy);
2726
2718
 
2727
2719
  for (Field **field= table->getFields() ; *field ; field++)
2728
2720
  {
2920
2912
      uint32_t offset= (field->offset(field->getTable()->record[0]) -
2921
2913
                    table->getShare()->null_bytes);
2922
2914
      assert(offset < table->getShare()->getRecordLength());
2923
 
      res= field->val_str_internal(&tmp, key + offset);
 
2915
      res= field->val_str(&tmp, key + offset);
2924
2916
    }
2925
2917
    else
2926
2918
      res= (*arg)->val_str(&tmp);
3051
3043
  {
3052
3044
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
3053
3045
    snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3054
 
    warning->set_msg(&getSession(), warn_buff);
 
3046
    warning->set_msg(current_session, warn_buff);
3055
3047
    warning= 0;
3056
3048
  }
3057
3049
 
3117
3109
  if (always_null)
3118
3110
    return 0;
3119
3111
  copy_fields(tmp_table_param);
3120
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
3121
 
    return true;
 
3112
  copy_funcs(tmp_table_param->items_to_copy);
3122
3113
 
3123
3114
  for (uint32_t i= 0; i < arg_count_field; i++)
3124
3115
  {