← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/sum.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/sum.cc
508
508
                                  Table *table,
509
509
                                  uint32_t convert_blob_length)
510
510
{
511
 
  Field *field;
 
511
  Field *field= NULL;
 
512
 
512
513
  switch (result_type()) {
513
514
  case REAL_RESULT:
514
515
    field= new Field_double(max_length, maybe_null, name, decimals, true);
515
516
    break;
 
517
 
516
518
  case INT_RESULT:
517
519
    field= new field::Int64(max_length, maybe_null, name, unsigned_flag);
518
520
    break;
 
521
 
519
522
  case STRING_RESULT:
520
523
    if (max_length/collation.collation->mbmaxlen <= 255 ||
521
524
        convert_blob_length > Field_varstring::MAX_SIZE ||
522
525
        !convert_blob_length)
 
526
    {
523
527
      return make_string_field(table);
 
528
    }
524
529
 
525
530
    table->setVariableWidth();
526
531
    field= new Field_varstring(convert_blob_length, maybe_null,
527
532
                               name, collation.collation);
528
533
    break;
 
534
 
529
535
  case DECIMAL_RESULT:
530
536
    field= new Field_decimal(max_length, maybe_null, name,
531
 
                                 decimals, unsigned_flag);
 
537
                             decimals, unsigned_flag);
532
538
    break;
 
539
 
533
540
  case ROW_RESULT:
534
 
  default:
535
541
    // This case should never be choosen
536
542
    assert(0);
537
543
    return 0;
538
544
  }
 
545
 
539
546
  if (field)
540
547
    field->init(table);
 
548
 
541
549
  return field;
542
550
}
543
551
 
647
655
    */
648
656
    break;
649
657
  case ROW_RESULT:
650
 
  default:
651
658
    assert(0);
652
659
  }
653
660
  collation.set(item->collation);
686
693
    max_length= item->max_length;
687
694
    break;
688
695
  case ROW_RESULT:
689
 
  default:
690
696
    assert(0);
691
697
  };
692
698
  /* MIN/MAX can return NULL for empty set indepedent of the used column */
798
804
    break;
799
805
  case INT_RESULT:
800
806
  case DECIMAL_RESULT:
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
 
  }
 
807
    {
 
808
      /* SUM result can't be longer than length(arg) + length(MAX_ROWS) */
 
809
      int precision= args[0]->decimal_precision() + DECIMAL_LONGLONG_DIGITS;
 
810
      max_length= my_decimal_precision_to_length(precision, decimals,
 
811
                                                 unsigned_flag);
 
812
      curr_dec_buff= 0;
 
813
      hybrid_type= DECIMAL_RESULT;
 
814
      my_decimal_set_zero(dec_buffs);
 
815
      break;
 
816
    }
811
817
  case ROW_RESULT:
812
 
  default:
813
818
    assert(0);
814
819
  }
815
 
  return;
816
820
}
817
821
 
818
822
 
966
970
    table_field_type= DRIZZLE_TYPE_DOUBLE;
967
971
    break;
968
972
  case INT_RESULT:
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 */
 
973
    /*
 
974
      Preserving int8, int16, int32 field types gives ~10% performance boost
 
975
      as the size of result tree becomes significantly smaller.
 
976
      Another speed up we gain by using int64_t for intermediate
 
977
      calculations. The range of int64 is enough to hold sum 2^32 distinct
 
978
      integers each <= 2^32.
 
979
    */
 
980
    if (table_field_type == DRIZZLE_TYPE_LONG)
 
981
    {
 
982
      val.traits= Hybrid_type_traits_fast_decimal::instance();
 
983
      break;
 
984
    }
 
985
    table_field_type= DRIZZLE_TYPE_LONGLONG;
 
986
    /* fallthrough */
983
987
  case DECIMAL_RESULT:
984
988
    val.traits= Hybrid_type_traits_decimal::instance();
985
989
    if (table_field_type != DRIZZLE_TYPE_LONGLONG)
986
990
      table_field_type= DRIZZLE_TYPE_DECIMAL;
987
991
    break;
988
992
  case ROW_RESULT:
989
 
  default:
990
993
    assert(0);
991
994
  }
 
995
 
992
996
  val.traits->fix_length_and_dec(this, args[0]);
993
997
}
994
998
 
1436
1440
    break;
1437
1441
  case INT_RESULT:
1438
1442
  case DECIMAL_RESULT:
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);
 
1443
    {
 
1444
      int precision= args[0]->decimal_precision()*2 + prec_increment;
 
1445
      decimals= min(args[0]->decimals + prec_increment, (unsigned int) DECIMAL_MAX_SCALE);
 
1446
      max_length= my_decimal_precision_to_length(precision, decimals,
 
1447
                                                 unsigned_flag);
1444
1448
 
1445
 
    break;
1446
 
  }
 
1449
      break;
 
1450
    }
1447
1451
  case ROW_RESULT:
1448
 
  default:
1449
1452
    assert(0);
1450
1453
  }
1451
 
  return;
1452
1454
}
1453
1455
 
1454
1456
 
1617
1619
  assert(fixed == 1);
1618
1620
  if (null_value)
1619
1621
    return 0.0;
 
1622
 
1620
1623
  switch (hybrid_type) {
1621
1624
  case STRING_RESULT:
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
 
  }
 
1625
    {
 
1626
      char *end_not_used;
 
1627
      int err_not_used;
 
1628
      String *res;  res=val_str(&str_value);
 
1629
      return (res ? my_strntod(res->charset(), (char*) res->ptr(), res->length(),
 
1630
                               &end_not_used, &err_not_used) : 0.0);
 
1631
    }
1629
1632
  case INT_RESULT:
1630
1633
    return (double) sum_int;
1631
1634
  case DECIMAL_RESULT:
1634
1637
  case REAL_RESULT:
1635
1638
    return sum;
1636
1639
  case ROW_RESULT:
1637
 
  default:
1638
1640
    // This case should never be choosen
1639
 
    assert(0);
1640
 
    return 0;
 
1641
    break;
1641
1642
  }
 
1643
 
 
1644
  assert(0);
 
1645
  return 0;
1642
1646
}
1643
1647
 
1644
1648
int64_t Item_sum_hybrid::val_int()
1666
1670
  assert(fixed == 1);
1667
1671
  if (null_value)
1668
1672
    return 0;
 
1673
 
1669
1674
  switch (hybrid_type) {
1670
1675
  case STRING_RESULT:
1671
1676
    string2my_decimal(E_DEC_FATAL_ERROR, &value, val);
1680
1685
    int2my_decimal(E_DEC_FATAL_ERROR, sum_int, unsigned_flag, val);
1681
1686
    break;
1682
1687
  case ROW_RESULT:
1683
 
  default:
1684
1688
    // This case should never be choosen
1685
1689
    assert(0);
1686
1690
    break;
1687
1691
  }
 
1692
 
1688
1693
  return val;                                   // Keep compiler happy
1689
1694
}
1690
1695
 
1695
1700
  assert(fixed == 1);
1696
1701
  if (null_value)
1697
1702
    return 0;
 
1703
 
1698
1704
  switch (hybrid_type) {
1699
1705
  case STRING_RESULT:
1700
1706
    return &value;
1710
1716
  case ROW_RESULT:
1711
1717
  default:
1712
1718
    // This case should never be choosen
1713
 
    assert(0);
1714
1719
    break;
1715
1720
  }
 
1721
 
1716
1722
  return str;                                   // Keep compiler happy
1717
1723
}
1718
1724
 
1750
1756
{
1751
1757
  switch (hybrid_type) {
1752
1758
  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))
1757
1759
    {
1758
 
      value.copy(*result);
1759
 
      null_value=0;
 
1760
      String *result=args[0]->val_str(&tmp_value);
 
1761
      if (!args[0]->null_value &&
 
1762
          (null_value || sortcmp(&value,result,collation.collation) > 0))
 
1763
      {
 
1764
        value.copy(*result);
 
1765
        null_value=0;
 
1766
      }
1760
1767
    }
1761
 
  }
1762
 
  break;
 
1768
    break;
1763
1769
  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)))
1770
1770
    {
1771
 
      sum_int=nr;
1772
 
      null_value=0;
 
1771
      int64_t nr=args[0]->val_int();
 
1772
      if (!args[0]->null_value && (null_value ||
 
1773
                                   (unsigned_flag &&
 
1774
                                    (uint64_t) nr < (uint64_t) sum_int) ||
 
1775
                                   (!unsigned_flag && nr < sum_int)))
 
1776
      {
 
1777
        sum_int=nr;
 
1778
        null_value=0;
 
1779
      }
1773
1780
    }
1774
 
  }
1775
 
  break;
 
1781
    break;
1776
1782
  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)))
1781
1783
    {
1782
 
      my_decimal2decimal(val, &sum_dec);
1783
 
      null_value= 0;
 
1784
      my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1785
      if (!args[0]->null_value &&
 
1786
          (null_value || (my_decimal_cmp(&sum_dec, val) > 0)))
 
1787
      {
 
1788
        my_decimal2decimal(val, &sum_dec);
 
1789
        null_value= 0;
 
1790
      }
1784
1791
    }
1785
 
  }
1786
 
  break;
 
1792
    break;
1787
1793
  case REAL_RESULT:
1788
 
  {
1789
 
    double nr= args[0]->val_real();
1790
 
    if (!args[0]->null_value && (null_value || nr < sum))
1791
1794
    {
1792
 
      sum=nr;
1793
 
      null_value=0;
 
1795
      double nr= args[0]->val_real();
 
1796
      if (!args[0]->null_value && (null_value || nr < sum))
 
1797
      {
 
1798
        sum=nr;
 
1799
        null_value=0;
 
1800
      }
1794
1801
    }
1795
 
  }
1796
 
  break;
 
1802
    break;
1797
1803
  case ROW_RESULT:
1798
 
  default:
1799
1804
    // This case should never be choosen
1800
1805
    assert(0);
1801
1806
    break;
1814
1819
{
1815
1820
  switch (hybrid_type) {
1816
1821
  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))
1821
1822
    {
1822
 
      value.copy(*result);
1823
 
      null_value=0;
 
1823
      String *result=args[0]->val_str(&tmp_value);
 
1824
      if (!args[0]->null_value &&
 
1825
          (null_value || sortcmp(&value,result,collation.collation) < 0))
 
1826
      {
 
1827
        value.copy(*result);
 
1828
        null_value=0;
 
1829
      }
1824
1830
    }
1825
 
  }
1826
 
  break;
 
1831
    break;
1827
1832
  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)))
1834
1833
    {
1835
 
      sum_int=nr;
1836
 
      null_value=0;
 
1834
      int64_t nr=args[0]->val_int();
 
1835
      if (!args[0]->null_value && (null_value ||
 
1836
                                   (unsigned_flag &&
 
1837
                                    (uint64_t) nr > (uint64_t) sum_int) ||
 
1838
                                   (!unsigned_flag && nr > sum_int)))
 
1839
      {
 
1840
        sum_int=nr;
 
1841
        null_value=0;
 
1842
      }
1837
1843
    }
1838
 
  }
1839
 
  break;
 
1844
    break;
1840
1845
  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)))
1845
1846
    {
1846
 
      my_decimal2decimal(val, &sum_dec);
1847
 
      null_value= 0;
 
1847
      my_decimal value_buff, *val= args[0]->val_decimal(&value_buff);
 
1848
      if (!args[0]->null_value &&
 
1849
          (null_value || (my_decimal_cmp(val, &sum_dec) > 0)))
 
1850
      {
 
1851
        my_decimal2decimal(val, &sum_dec);
 
1852
        null_value= 0;
 
1853
      }
1848
1854
    }
1849
 
  }
1850
 
  break;
 
1855
    break;
1851
1856
  case REAL_RESULT:
1852
 
  {
1853
 
    double nr= args[0]->val_real();
1854
 
    if (!args[0]->null_value && (null_value || nr > sum))
1855
1857
    {
1856
 
      sum=nr;
1857
 
      null_value=0;
 
1858
      double nr= args[0]->val_real();
 
1859
      if (!args[0]->null_value && (null_value || nr > sum))
 
1860
      {
 
1861
        sum=nr;
 
1862
        null_value=0;
 
1863
      }
1858
1864
    }
1859
 
  }
1860
 
  break;
 
1865
    break;
1861
1866
  case ROW_RESULT:
1862
 
  default:
1863
1867
    // This case should never be choosen
1864
1868
    assert(0);
1865
1869
    break;
1866
1870
  }
 
1871
 
1867
1872
  return 0;
1868
1873
}
1869
1874
 
1951
1956
{
1952
1957
  switch(hybrid_type) {
1953
1958
  case STRING_RESULT:
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)
 
1959
    {
 
1960
      char buff[MAX_FIELD_WIDTH];
 
1961
      String tmp(buff,sizeof(buff),result_field->charset()),*res;
 
1962
 
 
1963
      res=args[0]->val_str(&tmp);
 
1964
      if (args[0]->null_value)
 
1965
      {
2012
1966
        result_field->set_null();
 
1967
        result_field->reset();
 
1968
      }
2013
1969
      else
 
1970
      {
2014
1971
        result_field->set_notnull();
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
 
  }
 
1972
        result_field->store(res->ptr(),res->length(),tmp.charset());
 
1973
      }
 
1974
      break;
 
1975
    }
 
1976
  case INT_RESULT:
 
1977
    {
 
1978
      int64_t nr=args[0]->val_int();
 
1979
 
 
1980
      if (maybe_null)
 
1981
      {
 
1982
        if (args[0]->null_value)
 
1983
        {
 
1984
          nr=0;
 
1985
          result_field->set_null();
 
1986
        }
 
1987
        else
 
1988
          result_field->set_notnull();
 
1989
      }
 
1990
      result_field->store(nr, unsigned_flag);
 
1991
      break;
 
1992
    }
 
1993
  case REAL_RESULT:
 
1994
    {
 
1995
      double nr= args[0]->val_real();
 
1996
 
 
1997
      if (maybe_null)
 
1998
      {
 
1999
        if (args[0]->null_value)
 
2000
        {
 
2001
          nr=0.0;
 
2002
          result_field->set_null();
 
2003
        }
 
2004
        else
 
2005
          result_field->set_notnull();
 
2006
      }
 
2007
      result_field->store(nr);
 
2008
      break;
 
2009
    }
 
2010
  case DECIMAL_RESULT:
 
2011
    {
 
2012
      my_decimal value_buff, *arg_dec= args[0]->val_decimal(&value_buff);
 
2013
 
 
2014
      if (maybe_null)
 
2015
      {
 
2016
        if (args[0]->null_value)
 
2017
          result_field->set_null();
 
2018
        else
 
2019
          result_field->set_notnull();
 
2020
      }
 
2021
      /*
 
2022
        We must store zero in the field as we will use the field value in
 
2023
        add()
 
2024
      */
 
2025
      if (!arg_dec)                               // Null
 
2026
        arg_dec= &decimal_zero;
 
2027
      result_field->store_decimal(arg_dec);
 
2028
      break;
 
2029
    }
2025
2030
  case ROW_RESULT:
2026
 
  default:
2027
2031
    assert(0);
2028
2032
  }
2029
2033
}
2218
2222
  case DECIMAL_RESULT:
2219
2223
    min_max_update_decimal_field();
2220
2224
    break;
2221
 
  default:
 
2225
  case REAL_RESULT:
 
2226
  case ROW_RESULT:
2222
2227
    min_max_update_real_field();
2223
2228
  }
2224
2229
}