← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/sum.cc

  • Committer: Monty Taylor
  • Date: 2010-08-12 20:27:32 UTC
  • mto: (1720.1.5 build)
  • mto: This revision was merged to the branch mainline in revision 1722.
  • Revision ID: mordred@inaugust.com-20100812202732-9kzchbkvkyki4n3u
Merged libdrizzle directly into tree.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/sum.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
/**
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
 
 
531
 
    table->setVariableWidth();
532
524
    field= new Field_varstring(convert_blob_length, maybe_null,
533
 
                               name, collation.collation);
 
525
                               name, table->getMutableShare(), collation.collation);
534
526
    break;
535
 
 
536
527
  case DECIMAL_RESULT:
537
528
    field= new Field_decimal(max_length, maybe_null, name,
538
 
                             decimals, unsigned_flag);
 
529
                                 decimals, unsigned_flag);
539
530
    break;
540
 
 
541
531
  case ROW_RESULT:
 
532
  default:
542
533
    // This case should never be choosen
543
534
    assert(0);
544
535
    return 0;
545
536
  }
546
 
 
547
537
  if (field)
548
538
    field->init(table);
549
 
 
550
539
  return field;
551
540
}
552
541
 
584
573
}
585
574
 
586
575
 
587
 
type::Decimal *Item_sum_num::val_decimal(type::Decimal *decimal_value)
 
576
my_decimal *Item_sum_num::val_decimal(my_decimal *decimal_value)
588
577
{
589
578
  return val_decimal_from_real(decimal_value);
590
579
}
597
586
}
598
587
 
599
588
 
600
 
type::Decimal *Item_sum_int::val_decimal(type::Decimal *decimal_value)
 
589
my_decimal *Item_sum_int::val_decimal(my_decimal *decimal_value)
601
590
{
602
591
  return val_decimal_from_int(decimal_value);
603
592
}
644
633
    sum_int= item->sum_int;
645
634
    break;
646
635
  case DECIMAL_RESULT:
647
 
    class_decimal2decimal(&item->sum_dec, &sum_dec);
 
636
    my_decimal2decimal(&item->sum_dec, &sum_dec);
648
637
    break;
649
638
  case REAL_RESULT:
650
639
    sum= item->sum;
656
645
    */
657
646
    break;
658
647
  case ROW_RESULT:
 
648
  default:
659
649
    assert(0);
660
650
  }
661
651
  collation.set(item->collation);
684
674
    break;
685
675
  case DECIMAL_RESULT:
686
676
    max_length= item->max_length;
687
 
    sum_dec.set_zero();
 
677
    my_decimal_set_zero(&sum_dec);
688
678
    break;
689
679
  case REAL_RESULT:
690
680
    max_length= float_length(decimals);
694
684
    max_length= item->max_length;
695
685
    break;
696
686
  case ROW_RESULT:
 
687
  default:
697
688
    assert(0);
698
689
  };
699
690
  /* MIN/MAX can return NULL for empty set indepedent of the used column */
724
715
  {
725
716
    field= ((Item_field*) args[0])->field;
726
717
 
727
 
    if ((field= create_tmp_field_from_field(&getSession(), field, name, table,
 
718
    if ((field= create_tmp_field_from_field(current_session, field, name, table,
728
719
                                            NULL, convert_blob_length)))
729
720
      field->flags&= ~NOT_NULL_FLAG;
730
721
    return field;
745
736
  default:
746
737
    return Item_sum::create_tmp_field(group, table, convert_blob_length);
747
738
  }
748
 
 
749
739
  if (field)
750
740
    field->init(table);
751
 
 
752
741
  return field;
753
742
}
754
743
 
768
757
  /* TODO: check if the following assignments are really needed */
769
758
  if (hybrid_type == DECIMAL_RESULT)
770
759
  {
771
 
    class_decimal2decimal(item->dec_buffs, dec_buffs);
772
 
    class_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
 
760
    my_decimal2decimal(item->dec_buffs, dec_buffs);
 
761
    my_decimal2decimal(item->dec_buffs + 1, dec_buffs + 1);
773
762
  }
774
763
  else
775
764
    sum= item->sum;
787
776
  if (hybrid_type == DECIMAL_RESULT)
788
777
  {
789
778
    curr_dec_buff= 0;
790
 
    dec_buffs->set_zero();
 
779
    my_decimal_set_zero(dec_buffs);
791
780
  }
792
781
  else
793
782
    sum= 0.0;
807
796
    break;
808
797
  case INT_RESULT:
809
798
  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
 
    }
 
799
  {
 
800
    /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
 
801
    int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
 
802
    max_length= my_decimal_precision_to_length(precision, decimals,
 
803
                                               unsigned_flag);
 
804
    curr_dec_buff= 0;
 
805
    hybrid_type= DECIMAL_RESULT;
 
806
    my_decimal_set_zero(dec_buffs);
 
807
    break;
 
808
  }
820
809
  case ROW_RESULT:
 
810
  default:
821
811
    assert(0);
822
812
  }
 
813
  return;
823
814
}
824
815
 
825
816
 
827
818
{
828
819
  if (hybrid_type == DECIMAL_RESULT)
829
820
  {
830
 
    type::Decimal value, *val= args[0]->val_decimal(&value);
 
821
    my_decimal value, *val= args[0]->val_decimal(&value);
831
822
    if (!args[0]->null_value)
832
823
    {
833
 
      class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
 
824
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs + (curr_dec_buff^1),
834
825
                     val, dec_buffs + curr_dec_buff);
835
826
      curr_dec_buff^= 1;
836
827
      null_value= 0;
852
843
  if (hybrid_type == DECIMAL_RESULT)
853
844
  {
854
845
    int64_t result;
855
 
    (dec_buffs + curr_dec_buff)->val_int32(E_DEC_FATAL_ERROR, unsigned_flag, &result);
 
846
    my_decimal2int(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, unsigned_flag,
 
847
                   &result);
856
848
    return result;
857
849
  }
858
850
  return (int64_t) rint(val_real());
863
855
{
864
856
  assert(fixed == 1);
865
857
  if (hybrid_type == DECIMAL_RESULT)
866
 
    class_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
 
858
    my_decimal2double(E_DEC_FATAL_ERROR, dec_buffs + curr_dec_buff, &sum);
867
859
  return sum;
868
860
}
869
861
 
876
868
}
877
869
 
878
870
 
879
 
type::Decimal *Item_sum_sum::val_decimal(type::Decimal *val)
 
871
my_decimal *Item_sum_sum::val_decimal(my_decimal *val)
880
872
{
881
873
  if (hybrid_type == DECIMAL_RESULT)
882
874
    return (dec_buffs + curr_dec_buff);
939
931
 
940
932
  virtual void div(Hybrid_type *val, uint64_t u) const
941
933
  {
942
 
    int2_class_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
 
934
    int2my_decimal(E_DEC_FATAL_ERROR, val->integer, 0, val->dec_buf);
943
935
    val->used_dec_buf_no= 0;
944
936
    val->traits= Hybrid_type_traits_decimal::instance();
945
937
    val->traits->div(val, u);
972
964
    table_field_type= DRIZZLE_TYPE_DOUBLE;
973
965
    break;
974
966
  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 */
 
967
  /*
 
968
    Preserving int8, int16, int32 field types gives ~10% performance boost
 
969
    as the size of result tree becomes significantly smaller.
 
970
    Another speed up we gain by using int64_t for intermediate
 
971
    calculations. The range of int64 is enough to hold sum 2^32 distinct
 
972
    integers each <= 2^32.
 
973
  */
 
974
  if (table_field_type == DRIZZLE_TYPE_LONG)
 
975
  {
 
976
    val.traits= Hybrid_type_traits_fast_decimal::instance();
 
977
    break;
 
978
  }
 
979
  table_field_type= DRIZZLE_TYPE_LONGLONG;
 
980
  /* fallthrough */
989
981
  case DECIMAL_RESULT:
990
982
    val.traits= Hybrid_type_traits_decimal::instance();
991
983
    if (table_field_type != DRIZZLE_TYPE_LONGLONG)
992
984
      table_field_type= DRIZZLE_TYPE_DECIMAL;
993
985
    break;
994
986
  case ROW_RESULT:
 
987
  default:
995
988
    assert(0);
996
989
  }
997
 
 
998
990
  val.traits->fix_length_and_dec(this, args[0]);
999
991
}
1000
992
 
1033
1025
  field_def.init_for_tmp_table(table_field_type, args[0]->max_length,
1034
1026
                               args[0]->decimals, args[0]->maybe_null);
1035
1027
 
1036
 
  if (! (table= session->getInstanceTable(field_list)))
 
1028
  if (! (table= session->create_virtual_tmp_table(field_list)))
1037
1029
    return(true);
1038
1030
 
1039
1031
  /* XXX: check that the case of CHAR(0) works OK */
1133
1125
}
1134
1126
 
1135
1127
 
1136
 
type::Decimal *Item_sum_distinct::val_decimal(type::Decimal *to)
 
1128
my_decimal *Item_sum_distinct::val_decimal(my_decimal *to)
1137
1129
{
1138
1130
  calculate_val_and_count();
1139
1131
  if (null_value)
1165
1157
Item_sum_avg_distinct::fix_length_and_dec()
1166
1158
{
1167
1159
  Item_sum_distinct::fix_length_and_dec();
1168
 
  prec_increment= getSession().variables.div_precincrement;
 
1160
  prec_increment= current_session->variables.div_precincrement;
1169
1161
  /*
1170
1162
    AVG() will divide val by count. We need to reserve digits
1171
1163
    after decimal point as the result can be fractional.
1228
1220
{
1229
1221
  Item_sum_sum::fix_length_and_dec();
1230
1222
  maybe_null=null_value=1;
1231
 
  prec_increment= getSession().variables.div_precincrement;
1232
 
 
 
1223
  prec_increment= current_session->variables.div_precincrement;
1233
1224
  if (hybrid_type == DECIMAL_RESULT)
1234
1225
  {
1235
1226
    int precision= args[0]->decimal_precision() + prec_increment;
1236
1227
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
1237
 
    max_length= class_decimal_precision_to_length(precision, decimals,
 
1228
    max_length= my_decimal_precision_to_length(precision, decimals,
1238
1229
                                               unsigned_flag);
1239
1230
    f_precision= min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
1240
1231
    f_scale=  args[0]->decimals;
1241
 
    dec_bin_size= class_decimal_get_binary_size(f_precision, f_scale);
 
1232
    dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
1242
1233
  }
1243
1234
  else {
1244
1235
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) NOT_FIXED_DEC);
1264
1255
      The easiest way is to do this is to store both value in a string
1265
1256
      and unpack on access.
1266
1257
    */
1267
 
    table->setVariableWidth();
1268
1258
    field= new Field_varstring(((hybrid_type == DECIMAL_RESULT) ?
1269
1259
                                dec_bin_size : sizeof(double)) + sizeof(int64_t),
1270
 
                               0, name, &my_charset_bin);
 
1260
                               0, name, table->getMutableShare(), &my_charset_bin);
1271
1261
  }
1272
1262
  else if (hybrid_type == DECIMAL_RESULT)
1273
1263
    field= new Field_decimal(max_length, maybe_null, name,
1314
1304
}
1315
1305
 
1316
1306
 
1317
 
type::Decimal *Item_sum_avg::val_decimal(type::Decimal *val)
 
1307
my_decimal *Item_sum_avg::val_decimal(my_decimal *val)
1318
1308
{
1319
 
  type::Decimal sum_buff, cnt;
1320
 
  const type::Decimal *sum_dec;
 
1309
  my_decimal sum_buff, cnt;
 
1310
  const my_decimal *sum_dec;
1321
1311
  assert(fixed == 1);
1322
1312
  if (!count)
1323
1313
  {
1333
1323
    return val_decimal_from_real(val);
1334
1324
 
1335
1325
  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);
 
1326
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &cnt);
 
1327
  my_decimal_div(E_DEC_FATAL_ERROR, val, sum_dec, &cnt, prec_increment);
1338
1328
  return val;
1339
1329
}
1340
1330
 
1426
1416
void Item_sum_variance::fix_length_and_dec()
1427
1417
{
1428
1418
  maybe_null= null_value= 1;
1429
 
  prec_increment= getSession().variables.div_precincrement;
 
1419
  prec_increment= current_session->variables.div_precincrement;
1430
1420
 
1431
1421
  /*
1432
1422
    According to the SQL2003 standard (Part 2, Foundations; sec 10.9,
1443
1433
    break;
1444
1434
  case INT_RESULT:
1445
1435
  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);
 
1436
  {
 
1437
    int precision= args[0]->decimal_precision()*2 + prec_increment;
 
1438
    decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
 
1439
    max_length= my_decimal_precision_to_length(precision, decimals,
 
1440
                                               unsigned_flag);
1451
1441
 
1452
 
      break;
1453
 
    }
 
1442
    break;
 
1443
  }
1454
1444
  case ROW_RESULT:
 
1445
  default:
1455
1446
    assert(0);
1456
1447
  }
 
1448
  return;
1457
1449
}
1458
1450
 
1459
1451
 
1479
1471
      The easiest way is to do this is to store both value in a string
1480
1472
      and unpack on access.
1481
1473
    */
1482
 
    table->setVariableWidth();
1483
 
    field= new Field_varstring(sizeof(double)*2 + sizeof(int64_t), 0, name, &my_charset_bin);
 
1474
    field= new Field_varstring(sizeof(double)*2 + sizeof(int64_t), 0, name, table->getMutableShare(), &my_charset_bin);
1484
1475
  }
1485
1476
  else
1486
1477
    field= new Field_double(max_length, maybe_null, name, decimals, true);
1542
1533
}
1543
1534
 
1544
1535
 
1545
 
type::Decimal *Item_sum_variance::val_decimal(type::Decimal *dec_buf)
 
1536
my_decimal *Item_sum_variance::val_decimal(my_decimal *dec_buf)
1546
1537
{
1547
1538
  assert(fixed == 1);
1548
1539
  return val_decimal_from_real(dec_buf);
1606
1597
    sum_int= 0;
1607
1598
    break;
1608
1599
  case DECIMAL_RESULT:
1609
 
    sum_dec.set_zero();
 
1600
    my_decimal_set_zero(&sum_dec);
1610
1601
    break;
1611
1602
  case REAL_RESULT:
1612
1603
    sum= 0.0;
1622
1613
  assert(fixed == 1);
1623
1614
  if (null_value)
1624
1615
    return 0.0;
1625
 
 
1626
1616
  switch (hybrid_type) {
1627
1617
  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
 
    }
 
1618
  {
 
1619
    char *end_not_used;
 
1620
    int err_not_used;
 
1621
    String *res;  res=val_str(&str_value);
 
1622
    return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
 
1623
                             &end_not_used, &err_not_used) : 0.0);
 
1624
  }
1635
1625
  case INT_RESULT:
1636
1626
    return (double) sum_int;
1637
1627
  case DECIMAL_RESULT:
1638
 
    class_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
 
1628
    my_decimal2double(E_DEC_FATAL_ERROR, &sum_dec, &sum);
1639
1629
    return sum;
1640
1630
  case REAL_RESULT:
1641
1631
    return sum;
1642
1632
  case ROW_RESULT:
 
1633
  default:
1643
1634
    // This case should never be choosen
1644
 
    break;
 
1635
    assert(0);
 
1636
    return 0;
1645
1637
  }
1646
 
 
1647
 
  assert(0);
1648
 
  return 0;
1649
1638
}
1650
1639
 
1651
1640
int64_t Item_sum_hybrid::val_int()
1659
1648
  case DECIMAL_RESULT:
1660
1649
  {
1661
1650
    int64_t result;
1662
 
    sum_dec.val_int32(E_DEC_FATAL_ERROR, unsigned_flag, &result);
 
1651
    my_decimal2int(E_DEC_FATAL_ERROR, &sum_dec, unsigned_flag, &result);
1663
1652
    return sum_int;
1664
1653
  }
1665
1654
  default:
1668
1657
}
1669
1658
 
1670
1659
 
1671
 
type::Decimal *Item_sum_hybrid::val_decimal(type::Decimal *val)
 
1660
my_decimal *Item_sum_hybrid::val_decimal(my_decimal *val)
1672
1661
{
1673
1662
  assert(fixed == 1);
1674
1663
  if (null_value)
1675
1664
    return 0;
1676
 
 
1677
1665
  switch (hybrid_type) {
1678
1666
  case STRING_RESULT:
1679
 
    val->store(E_DEC_FATAL_ERROR, &value);
 
1667
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
1680
1668
    break;
1681
1669
  case REAL_RESULT:
1682
 
    double2_class_decimal(E_DEC_FATAL_ERROR, sum, val);
 
1670
    double2my_decimal(E_DEC_FATAL_ERROR, sum, val);
1683
1671
    break;
1684
1672
  case DECIMAL_RESULT:
1685
1673
    val= &sum_dec;
1686
1674
    break;
1687
1675
  case INT_RESULT:
1688
 
    int2_class_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
 
1676
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
1689
1677
    break;
1690
1678
  case ROW_RESULT:
 
1679
  default:
1691
1680
    // This case should never be choosen
1692
1681
    assert(0);
1693
1682
    break;
1694
1683
  }
1695
 
 
1696
1684
  return val;                                   // Keep compiler happy
1697
1685
}
1698
1686
 
1703
1691
  assert(fixed == 1);
1704
1692
  if (null_value)
1705
1693
    return 0;
1706
 
 
1707
1694
  switch (hybrid_type) {
1708
1695
  case STRING_RESULT:
1709
1696
    return &value;
1711
1698
    str->set_real(sum,decimals, &my_charset_bin);
1712
1699
    break;
1713
1700
  case DECIMAL_RESULT:
1714
 
    class_decimal2string(&sum_dec, 0, str);
 
1701
    my_decimal2string(E_DEC_FATAL_ERROR, &sum_dec, 0, 0, 0, str);
1715
1702
    return str;
1716
1703
  case INT_RESULT:
1717
1704
    str->set_int(sum_int, unsigned_flag, &my_charset_bin);
1719
1706
  case ROW_RESULT:
1720
1707
  default:
1721
1708
    // This case should never be choosen
 
1709
    assert(0);
1722
1710
    break;
1723
1711
  }
1724
 
 
1725
1712
  return str;                                   // Keep compiler happy
1726
1713
}
1727
1714
 
1759
1746
{
1760
1747
  switch (hybrid_type) {
1761
1748
  case STRING_RESULT:
 
1749
  {
 
1750
    String *result=args[0]->val_str(&tmp_value);
 
1751
    if (!args[0]->null_value &&
 
1752
        (null_value || sortcmp(&value,result,collation.collation) > 0))
1762
1753
    {
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
 
      }
 
1754
      value.copy(*result);
 
1755
      null_value=0;
1770
1756
    }
1771
 
    break;
 
1757
  }
 
1758
  break;
1772
1759
  case INT_RESULT:
 
1760
  {
 
1761
    int64_t nr=args[0]->val_int();
 
1762
    if (!args[0]->null_value && (null_value ||
 
1763
                                 (unsigned_flag &&
 
1764
                                  (uint64_t) nr < (uint64_t) sum_int) ||
 
1765
                                 (!unsigned_flag && nr < sum_int)))
1773
1766
    {
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
 
      }
 
1767
      sum_int=nr;
 
1768
      null_value=0;
1783
1769
    }
1784
 
    break;
 
1770
  }
 
1771
  break;
1785
1772
  case DECIMAL_RESULT:
 
1773
  {
 
1774
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1775
    if (!args[0]->null_value &&
 
1776
        (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
1786
1777
    {
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
 
      }
 
1778
      my_decimal2decimal(val, &sum_dec);
 
1779
      null_value= 0;
1794
1780
    }
1795
 
    break;
 
1781
  }
 
1782
  break;
1796
1783
  case REAL_RESULT:
 
1784
  {
 
1785
    double nr= args[0]->val_real();
 
1786
    if (!args[0]->null_value && (null_value || nr < sum))
1797
1787
    {
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
 
      }
 
1788
      sum=nr;
 
1789
      null_value=0;
1804
1790
    }
1805
 
    break;
 
1791
  }
 
1792
  break;
1806
1793
  case ROW_RESULT:
 
1794
  default:
1807
1795
    // This case should never be choosen
1808
1796
    assert(0);
1809
1797
    break;
1822
1810
{
1823
1811
  switch (hybrid_type) {
1824
1812
  case STRING_RESULT:
 
1813
  {
 
1814
    String *result=args[0]->val_str(&tmp_value);
 
1815
    if (!args[0]->null_value &&
 
1816
        (null_value || sortcmp(&value,result,collation.collation) < 0))
1825
1817
    {
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
 
      }
 
1818
      value.copy(*result);
 
1819
      null_value=0;
1833
1820
    }
1834
 
    break;
 
1821
  }
 
1822
  break;
1835
1823
  case INT_RESULT:
 
1824
  {
 
1825
    int64_t nr=args[0]->val_int();
 
1826
    if (!args[0]->null_value && (null_value ||
 
1827
                                 (unsigned_flag &&
 
1828
                                  (uint64_t) nr > (uint64_t) sum_int) ||
 
1829
                                 (!unsigned_flag && nr > sum_int)))
1836
1830
    {
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
 
      }
 
1831
      sum_int=nr;
 
1832
      null_value=0;
1846
1833
    }
1847
 
    break;
 
1834
  }
 
1835
  break;
1848
1836
  case DECIMAL_RESULT:
 
1837
  {
 
1838
    my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1839
    if (!args[0]->null_value &&
 
1840
        (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
1849
1841
    {
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
 
      }
 
1842
      my_decimal2decimal(val, &sum_dec);
 
1843
      null_value= 0;
1857
1844
    }
1858
 
    break;
 
1845
  }
 
1846
  break;
1859
1847
  case REAL_RESULT:
 
1848
  {
 
1849
    double nr= args[0]->val_real();
 
1850
    if (!args[0]->null_value && (null_value || nr > sum))
1860
1851
    {
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
 
      }
 
1852
      sum=nr;
 
1853
      null_value=0;
1867
1854
    }
1868
 
    break;
 
1855
  }
 
1856
  break;
1869
1857
  case ROW_RESULT:
 
1858
  default:
1870
1859
    // This case should never be choosen
1871
1860
    assert(0);
1872
1861
    break;
1873
1862
  }
1874
 
 
1875
1863
  return 0;
1876
1864
}
1877
1865
 
1959
1947
{
1960
1948
  switch(hybrid_type) {
1961
1949
  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
 
      {
 
1950
  {
 
1951
    char buff[MAX_FIELD_WIDTH];
 
1952
    String tmp(buff,sizeof(buff),result_field->charset()),*res;
 
1953
 
 
1954
    res=args[0]->val_str(&tmp);
 
1955
    if (args[0]->null_value)
 
1956
    {
 
1957
      result_field->set_null();
 
1958
      result_field->reset();
 
1959
    }
 
1960
    else
 
1961
    {
 
1962
      result_field->set_notnull();
 
1963
      result_field->store(res->ptr(),res->length(),tmp.charset());
 
1964
    }
 
1965
    break;
 
1966
  }
 
1967
  case INT_RESULT:
 
1968
  {
 
1969
    int64_t nr=args[0]->val_int();
 
1970
 
 
1971
    if (maybe_null)
 
1972
    {
 
1973
      if (args[0]->null_value)
 
1974
      {
 
1975
        nr=0;
 
1976
        result_field->set_null();
 
1977
      }
 
1978
      else
 
1979
        result_field->set_notnull();
 
1980
    }
 
1981
    result_field->store(nr, unsigned_flag);
 
1982
    break;
 
1983
  }
 
1984
  case REAL_RESULT:
 
1985
  {
 
1986
    double nr= args[0]->val_real();
 
1987
 
 
1988
    if (maybe_null)
 
1989
    {
 
1990
      if (args[0]->null_value)
 
1991
      {
 
1992
        nr=0.0;
 
1993
        result_field->set_null();
 
1994
      }
 
1995
      else
 
1996
        result_field->set_notnull();
 
1997
    }
 
1998
    result_field->store(nr);
 
1999
    break;
 
2000
  }
 
2001
  case DECIMAL_RESULT:
 
2002
  {
 
2003
    my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
 
2004
 
 
2005
    if (maybe_null)
 
2006
    {
 
2007
      if (args[0]->null_value)
1969
2008
        result_field->set_null();
1970
 
        result_field->reset();
1971
 
      }
1972
2009
      else
1973
 
      {
1974
2010
        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
 
    }
 
2011
    }
 
2012
    /*
 
2013
      We must store zero in the field as we will use the field value in
 
2014
      add()
 
2015
    */
 
2016
    if (!arg_dec)                               // Null
 
2017
      arg_dec= &decimal_zero;
 
2018
    result_field->store_decimal(arg_dec);
 
2019
    break;
 
2020
  }
2033
2021
  case ROW_RESULT:
 
2022
  default:
2034
2023
    assert(0);
2035
2024
  }
2036
2025
}
2040
2029
{
2041
2030
  if (hybrid_type == DECIMAL_RESULT)
2042
2031
  {
2043
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2032
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2044
2033
    if (!arg_val)                               // Null
2045
2034
      arg_val= &decimal_zero;
2046
2035
    result_field->store_decimal(arg_val);
2075
2064
  if (hybrid_type == DECIMAL_RESULT)
2076
2065
  {
2077
2066
    int64_t tmp;
2078
 
    type::Decimal value, *arg_dec= args[0]->val_decimal(&value);
 
2067
    my_decimal value, *arg_dec= args[0]->val_decimal(&value);
2079
2068
    if (args[0]->null_value)
2080
2069
    {
2081
2070
      arg_dec= &decimal_zero;
2083
2072
    }
2084
2073
    else
2085
2074
      tmp= 1;
2086
 
    arg_dec->val_binary(E_DEC_FATAL_ERROR, res, f_precision, f_scale);
 
2075
    my_decimal2binary(E_DEC_FATAL_ERROR, arg_dec, res, f_precision, f_scale);
2087
2076
    res+= dec_bin_size;
2088
2077
    int8store(res, tmp);
2089
2078
  }
2127
2116
{
2128
2117
  if (hybrid_type == DECIMAL_RESULT)
2129
2118
  {
2130
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2119
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2131
2120
    if (!args[0]->null_value)
2132
2121
    {
2133
2122
      if (!result_field->is_null())
2134
2123
      {
2135
 
        type::Decimal field_value,
 
2124
        my_decimal field_value,
2136
2125
                   *field_val= result_field->val_decimal(&field_value);
2137
 
        class_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
 
2126
        my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, field_val);
2138
2127
        result_field->store_decimal(dec_buffs);
2139
2128
      }
2140
2129
      else
2179
2168
  unsigned char *res=result_field->ptr;
2180
2169
  if (hybrid_type == DECIMAL_RESULT)
2181
2170
  {
2182
 
    type::Decimal value, *arg_val= args[0]->val_decimal(&value);
 
2171
    my_decimal value, *arg_val= args[0]->val_decimal(&value);
2183
2172
    if (!args[0]->null_value)
2184
2173
    {
2185
 
      binary2_class_decimal(E_DEC_FATAL_ERROR, res,
 
2174
      binary2my_decimal(E_DEC_FATAL_ERROR, res,
2186
2175
                        dec_buffs + 1, f_precision, f_scale);
2187
2176
      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);
 
2177
      my_decimal_add(E_DEC_FATAL_ERROR, dec_buffs, arg_val, dec_buffs + 1);
 
2178
      my_decimal2binary(E_DEC_FATAL_ERROR, dec_buffs,
 
2179
                        res, f_precision, f_scale);
2190
2180
      res+= dec_bin_size;
2191
2181
      field_count++;
2192
2182
      int8store(res, field_count);
2224
2214
  case DECIMAL_RESULT:
2225
2215
    min_max_update_decimal_field();
2226
2216
    break;
2227
 
  case REAL_RESULT:
2228
 
  case ROW_RESULT:
 
2217
  default:
2229
2218
    min_max_update_real_field();
2230
2219
  }
2231
2220
}
2238
2227
 
2239
2228
  if (!args[0]->null_value)
2240
2229
  {
2241
 
    result_field->val_str_internal(&tmp_value);
 
2230
    result_field->val_str(&tmp_value);
2242
2231
 
2243
2232
    if (result_field->is_null() ||
2244
2233
        (cmp_sign * sortcmp(res_str,&tmp_value,collation.collation)) < 0)
2304
2293
Item_sum_hybrid::min_max_update_decimal_field()
2305
2294
{
2306
2295
  /* 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);
 
2296
  my_decimal old_val, nr_val;
 
2297
  const my_decimal *old_nr= result_field->val_decimal(&old_val);
 
2298
  const my_decimal *nr= args[0]->val_decimal(&nr_val);
2310
2299
  if (!args[0]->null_value)
2311
2300
  {
2312
2301
    if (result_field->is_null(0))
2313
2302
      old_nr=nr;
2314
2303
    else
2315
2304
    {
2316
 
      bool res= class_decimal_cmp(old_nr, nr) > 0;
 
2305
      bool res= my_decimal_cmp(old_nr, nr) > 0;
2317
2306
      /* (cmp_sign > 0 && res) || (!(cmp_sign > 0) && !res) */
2318
2307
      if ((cmp_sign > 0) ^ (!res))
2319
2308
        old_nr=nr;
2370
2359
}
2371
2360
 
2372
2361
 
2373
 
type::Decimal *Item_avg_field::val_decimal(type::Decimal *dec_buf)
 
2362
my_decimal *Item_avg_field::val_decimal(my_decimal *dec_buf)
2374
2363
{
2375
2364
  // fix_fields() never calls for this Item
2376
2365
  if (hybrid_type == REAL_RESULT)
2380
2369
  if ((null_value= !count))
2381
2370
    return 0;
2382
2371
 
2383
 
  type::Decimal dec_count, dec_field;
2384
 
  binary2_class_decimal(E_DEC_FATAL_ERROR,
 
2372
  my_decimal dec_count, dec_field;
 
2373
  binary2my_decimal(E_DEC_FATAL_ERROR,
2385
2374
                    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,
 
2375
  int2my_decimal(E_DEC_FATAL_ERROR, count, 0, &dec_count);
 
2376
  my_decimal_div(E_DEC_FATAL_ERROR, dec_buf,
2388
2377
                 &dec_field, &dec_count, prec_increment);
2389
2378
  return dec_buf;
2390
2379
}
2415
2404
}
2416
2405
 
2417
2406
 
2418
 
type::Decimal *Item_std_field::val_decimal(type::Decimal *dec_buf)
 
2407
my_decimal *Item_std_field::val_decimal(my_decimal *dec_buf)
2419
2408
{
2420
2409
  /*
2421
2410
    We can't call val_decimal_from_real() for DECIMAL_RESULT as
2422
2411
    Item_variance_field::val_real() would cause an infinite loop
2423
2412
  */
2424
 
  type::Decimal tmp_dec, *dec;
 
2413
  my_decimal tmp_dec, *dec;
2425
2414
  double nr;
2426
2415
  if (hybrid_type == REAL_RESULT)
2427
2416
    return val_decimal_from_real(dec_buf);
2429
2418
  dec= Item_variance_field::val_decimal(dec_buf);
2430
2419
  if (!dec)
2431
2420
    return 0;
2432
 
  class_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
 
2421
  my_decimal2double(E_DEC_FATAL_ERROR, dec, &nr);
2433
2422
  assert(nr >= 0.0);
2434
2423
  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);
 
2424
  double2my_decimal(E_DEC_FATAL_ERROR, nr, &tmp_dec);
 
2425
  my_decimal_round(E_DEC_FATAL_ERROR, &tmp_dec, decimals, false, dec_buf);
2437
2426
  return dec_buf;
2438
2427
}
2439
2428
 
2610
2599
  tmp_table_param->force_copy_fields= force_copy_fields;
2611
2600
  assert(table == 0);
2612
2601
 
2613
 
  if (!(table= create_tmp_table(session, tmp_table_param, list, (Order*) 0, 1,
 
2602
  if (!(table= create_tmp_table(session, tmp_table_param, list, (order_st*) 0, 1,
2614
2603
                                0,
2615
2604
                                (select_lex->options | session->options),
2616
2605
                                HA_POS_ERROR, (char*)"")))
2667
2656
        uint32_t *length;
2668
2657
        compare_key= (qsort_cmp2) composite_key_cmp;
2669
2658
        cmp_arg= (void*) this;
2670
 
        field_lengths= (uint32_t*) session->getMemRoot()->allocate(table->getShare()->sizeFields() * sizeof(uint32_t));
 
2659
        field_lengths= (uint32_t*) session->alloc(table->getShare()->sizeFields() * sizeof(uint32_t));
2671
2660
        for (tree_key_length= 0, length= field_lengths, field= table->getFields();
2672
2661
             field < field_end; ++field, ++length)
2673
2662
        {
2721
2710
  if (always_null)
2722
2711
    return 0;
2723
2712
  copy_fields(tmp_table_param);
2724
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
2725
 
    return true;
 
2713
  copy_funcs(tmp_table_param->items_to_copy);
2726
2714
 
2727
2715
  for (Field **field= table->getFields() ; *field ; field++)
2728
2716
  {
2846
2834
                                    const void* key2)
2847
2835
{
2848
2836
  Item_func_group_concat* grp_item= (Item_func_group_concat*) arg;
2849
 
  Order **order_item, **end;
 
2837
  order_st **order_item, **end;
2850
2838
  Table *table= grp_item->table;
2851
2839
 
2852
2840
  for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
2920
2908
      uint32_t offset= (field->offset(field->getTable()->record[0]) -
2921
2909
                    table->getShare()->null_bytes);
2922
2910
      assert(offset < table->getShare()->getRecordLength());
2923
 
      res= field->val_str_internal(&tmp, key + offset);
 
2911
      res= field->val_str(&tmp, key + offset);
2924
2912
    }
2925
2913
    else
2926
2914
      res= (*arg)->val_str(&tmp);
2990
2978
    order - arg_count_order
2991
2979
  */
2992
2980
  if (!(args= (Item**) memory::sql_alloc(sizeof(Item*) * arg_count +
2993
 
                                 sizeof(Order*)*arg_count_order)))
 
2981
                                 sizeof(order_st*)*arg_count_order)))
2994
2982
    return;
2995
2983
 
2996
 
  order= (Order**)(args + arg_count);
 
2984
  order= (order_st**)(args + arg_count);
2997
2985
 
2998
2986
  /* fill args items of show and sort */
2999
2987
  List_iterator_fast<Item> li(*select_list);
3003
2991
 
3004
2992
  if (arg_count_order)
3005
2993
  {
3006
 
    Order **order_ptr= order;
3007
 
    for (Order *order_item= (Order*) order_list->first;
 
2994
    order_st **order_ptr= order;
 
2995
    for (order_st *order_item= (order_st*) order_list->first;
3008
2996
         order_item != NULL;
3009
2997
         order_item= order_item->next)
3010
2998
    {
3051
3039
  {
3052
3040
    char warn_buff[DRIZZLE_ERRMSG_SIZE];
3053
3041
    snprintf(warn_buff, sizeof(warn_buff), ER(ER_CUT_VALUE_GROUP_CONCAT), count_cut_values);
3054
 
    warning->set_msg(&getSession(), warn_buff);
 
3042
    warning->set_msg(current_session, warn_buff);
3055
3043
    warning= 0;
3056
3044
  }
3057
3045
 
3117
3105
  if (always_null)
3118
3106
    return 0;
3119
3107
  copy_fields(tmp_table_param);
3120
 
  if (copy_funcs(tmp_table_param->items_to_copy, table->in_use))
3121
 
    return true;
 
3108
  copy_funcs(tmp_table_param->items_to_copy);
3122
3109
 
3123
3110
  for (uint32_t i= 0; i < arg_count_field; i++)
3124
3111
  {
3272
3259
    field list.
3273
3260
  */
3274
3261
  if (!(table= create_tmp_table(session, tmp_table_param, all_fields,
3275
 
                                (Order*) 0, 0, true,
 
3262
                                (order_st*) 0, 0, true,
3276
3263
                                (select_lex->options | session->options),
3277
3264
                                HA_POS_ERROR, (char*) "")))
3278
3265
  {