← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/functions/func.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/functions/func.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
 
20
using namespace std;
 
21
#include <drizzled/server_includes.h>
 
22
 
 
23
#include CSTDINT_H
 
24
#include <cassert>
21
25
 
22
26
#include <drizzled/sql_string.h>
23
27
#include <drizzled/sql_list.h>
24
28
 
25
 
#include <drizzled/function/math/int.h>
26
 
#include <drizzled/field/int64_t.h>
27
 
#include <drizzled/field/long.h>
28
 
#include <drizzled/field/double.h>
29
 
#include <drizzled/field/decimal.h>
30
 
#include <drizzled/session.h>
31
 
#include <drizzled/error.h>
32
 
#include <drizzled/check_stack_overrun.h>
33
 
#include <limits>
34
 
#include <algorithm>
35
 
 
36
 
using namespace std;
37
 
 
38
 
namespace drizzled
39
 
{
 
29
#include <drizzled/functions/int.h>
 
30
#include CMATH_H
 
31
#include <drizzled/util/math.h>
 
32
 
 
33
#if defined(CMATH_NAMESPACE)
 
34
using namespace CMATH_NAMESPACE;
 
35
#endif
 
36
 
40
37
 
41
38
 
42
39
void Item_func::set_arguments(List<Item> &list)
44
41
  allowed_arg_cols= 1;
45
42
  arg_count=list.elements;
46
43
  args= tmp_arg;                                // If 2 arguments
47
 
  if (arg_count <= 2 || (args=(Item**) memory::sql_alloc(sizeof(Item*)*arg_count)))
 
44
  if (arg_count <= 2 || (args=(Item**) sql_alloc(sizeof(Item*)*arg_count)))
48
45
  {
49
46
    List_iterator_fast<Item> li(list);
50
47
    Item *item;
121
118
*/
122
119
 
123
120
bool
124
 
Item_func::fix_fields(Session *session, Item **)
 
121
Item_func::fix_fields(Session *session, Item **ref __attribute__((unused)))
125
122
{
126
123
  assert(fixed == 0);
127
124
  Item **arg,**arg_end;
143
140
        We shouldn't call fix_fields() twice, so check 'fixed' field first
144
141
      */
145
142
      if ((!(*arg)->fixed && (*arg)->fix_fields(session, arg)))
146
 
        return true;
 
143
        return true;        /* purecov: inspected */
147
144
      item= *arg;
148
145
 
149
146
      if (allowed_arg_cols)
178
175
}
179
176
 
180
177
 
181
 
void Item_func::fix_after_pullout(Select_Lex *new_parent,
182
 
                                  Item **)
 
178
void Item_func::fix_after_pullout(st_select_lex *new_parent,
 
179
                                  Item **ref __attribute__((unused)))
183
180
{
184
181
  Item **arg,**arg_end;
185
182
 
224
221
    Item **arg,**arg_end;
225
222
 
226
223
    switch (order) {
227
 
    case (T_PREFIX):
 
224
    case(PREFIX):
228
225
      (*traverser)(this, argument);
229
226
      for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
230
227
      {
231
228
        (*arg)->traverse_cond(traverser, argument, order);
232
229
      }
233
230
      break;
234
 
    case (T_POSTFIX):
 
231
    case (POSTFIX):
235
232
      for (arg= args, arg_end= args+arg_count; arg != arg_end; arg++)
236
233
      {
237
234
        (*arg)->traverse_cond(traverser, argument, order);
342
339
{
343
340
  Item **arg, **arg_end;
344
341
  for (arg= args, arg_end= args+arg_count; arg != arg_end ; arg++)
345
 
    (*arg)->split_sum_func(session, ref_pointer_array, fields, arg, true);
 
342
    (*arg)->split_sum_func2(session, ref_pointer_array, fields, arg, true);
346
343
}
347
344
 
348
345
 
464
461
    break;
465
462
  case STRING_RESULT:
466
463
    return make_string_field(table);
 
464
    break;
467
465
  case DECIMAL_RESULT:
468
 
    field= new Field_decimal(my_decimal_precision_to_length(decimal_precision(),
469
 
                                                            decimals,
470
 
                                                            unsigned_flag),
471
 
                             maybe_null,
472
 
                             name,
473
 
                             decimals,
474
 
                             unsigned_flag);
 
466
    field= new Field_new_decimal(
 
467
                       my_decimal_precision_to_length(decimal_precision(),
 
468
                                                      decimals,
 
469
                                                      unsigned_flag),
 
470
                       maybe_null, name, decimals, unsigned_flag);
475
471
    break;
476
472
  case ROW_RESULT:
477
473
  default:
520
516
 
521
517
double Item_func::fix_result(double value)
522
518
{
523
 
  static double fix_infinity= numeric_limits<double>::infinity();
524
 
 
525
 
  if (value != fix_infinity && value != -fix_infinity)
 
519
  if (isfinite(value))
526
520
    return value;
527
521
  null_value=1;
528
522
  return 0.0;
529
523
}
530
 
 
531
 
 
532
 
void Item_func::fix_num_length_and_dec()
533
 
{
534
 
  uint32_t fl_length= 0;
535
 
  decimals=0;
536
 
  for (uint32_t i=0 ; i < arg_count ; i++)
537
 
  {
538
 
    set_if_bigger(decimals,args[i]->decimals);
539
 
    set_if_bigger(fl_length, args[i]->max_length);
540
 
  }
541
 
  max_length=float_length(decimals);
542
 
  if (fl_length > max_length)
543
 
  {
544
 
    decimals= NOT_FIXED_DEC;
545
 
    max_length= float_length(NOT_FIXED_DEC);
546
 
  }
547
 
}
548
 
 
549
 
/**
550
 
  Set max_length/decimals of function if function is fixed point and
551
 
  result length/precision depends on argument ones.
552
 
*/
553
 
 
554
 
void Item_func::count_decimal_length()
555
 
{
556
 
  int max_int_part= 0;
557
 
  decimals= 0;
558
 
  unsigned_flag= 1;
559
 
  for (uint32_t i= 0 ; i < arg_count ; i++)
560
 
  {
561
 
    set_if_bigger(decimals, args[i]->decimals);
562
 
    set_if_bigger(max_int_part, args[i]->decimal_int_part());
563
 
    set_if_smaller(unsigned_flag, args[i]->unsigned_flag);
564
 
  }
565
 
  int precision= min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
566
 
  max_length= my_decimal_precision_to_length(precision, decimals,
567
 
                                             unsigned_flag);
568
 
}
569
 
 
570
 
 
571
 
/**
572
 
  Set max_length of if it is maximum length of its arguments.
573
 
*/
574
 
 
575
 
void Item_func::count_only_length()
576
 
{
577
 
  max_length= 0;
578
 
  unsigned_flag= 0;
579
 
  for (uint32_t i=0 ; i < arg_count ; i++)
580
 
  {
581
 
    set_if_bigger(max_length, args[i]->max_length);
582
 
    set_if_bigger(unsigned_flag, args[i]->unsigned_flag);
583
 
  }
584
 
}
585
 
 
586
 
 
587
 
/**
588
 
  Set max_length/decimals of function if function is floating point and
589
 
  result length/precision depends on argument ones.
590
 
*/
591
 
 
592
 
void Item_func::count_real_length()
593
 
{
594
 
  uint32_t length= 0;
595
 
  decimals= 0;
596
 
  max_length= 0;
597
 
  for (uint32_t i=0 ; i < arg_count ; i++)
598
 
  {
599
 
    if (decimals != NOT_FIXED_DEC)
600
 
    {
601
 
      set_if_bigger(decimals, args[i]->decimals);
602
 
      set_if_bigger(length, (args[i]->max_length - args[i]->decimals));
603
 
    }
604
 
    set_if_bigger(max_length, args[i]->max_length);
605
 
  }
606
 
  if (decimals != NOT_FIXED_DEC)
607
 
  {
608
 
    max_length= length;
609
 
    length+= decimals;
610
 
    if (length < max_length)  // If previous operation gave overflow
611
 
      max_length= UINT32_MAX;
612
 
    else
613
 
      max_length= length;
614
 
  }
615
 
}
616
 
 
617
 
 
618
 
 
619
 
void Item_func::signal_divide_by_null()
620
 
{
621
 
  Session *session= current_session;
622
 
  push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
623
 
  null_value= 1;
624
 
}
625
 
 
626
 
 
627
 
Item *Item_func::get_tmp_table_item(Session *session)
628
 
{
629
 
  if (!with_sum_func && !const_item() && functype() != SUSERVAR_FUNC)
630
 
    return new Item_field(result_field);
631
 
  return copy_or_same(session);
632
 
}
633
 
 
634
 
 
635
 
} /* namespace drizzled */