← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/function/math/divide.cc

  • Committer: Stewart Smith
  • Date: 2009-05-15 06:57:12 UTC
  • mto: (991.1.5 for-brian)
  • mto: This revision was merged to the branch mainline in revision 1022.
  • Revision ID: stewart@flamingspork.com-20090515065712-bmionylacjmexmmm
https://launchpad.net/bugs/314567
Make sql_mode=NO_AUTO_VALUE_ON_ZERO default for Drizzle.

Also fix DEFAULT keyword handling for auto-increment so that it defaults to
NULL and not 0 so that the following is valid and generates two auto-inc
values:

create table t1 (a int auto_increment primary key)
insert into t1 (a) values (default);
insert into t1 (a) values (default);

Important to note that 0 is no longer magic. So this gives you duplicate
primary key error:

insert into t1 (a) values(0);
insert into t1 (a) values(0);

as you've inserted the explicit value of 0 twice.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/function/math/divide.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
21
 
 
 
20
#include <drizzled/server_includes.h>
 
21
#include CSTDINT_H
22
22
#include <drizzled/function/math/divide.h>
23
23
#include <drizzled/session.h>
24
24
 
25
 
#include <algorithm>
26
 
 
27
 
using namespace std;
28
 
 
29
 
namespace drizzled
30
 
{
31
 
 
32
25
double Item_func_div::real_op()
33
26
{
34
27
  assert(fixed == 1);
45
38
}
46
39
 
47
40
 
48
 
type::Decimal *Item_func_div::decimal_op(type::Decimal *decimal_value)
 
41
my_decimal *Item_func_div::decimal_op(my_decimal *decimal_value)
49
42
{
50
 
  type::Decimal value1, *val1;
51
 
  type::Decimal value2, *val2;
 
43
  my_decimal value1, *val1;
 
44
  my_decimal value2, *val2;
52
45
  int err;
53
46
 
54
47
  val1= args[0]->val_decimal(&value1);
57
50
  val2= args[1]->val_decimal(&value2);
58
51
  if ((null_value= args[1]->null_value))
59
52
    return 0;
60
 
  if ((err= class_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value,
 
53
  if ((err= my_decimal_div(E_DEC_FATAL_ERROR & ~E_DEC_DIV_ZERO, decimal_value,
61
54
                           val1, val2, prec_increment)) > 3)
62
55
  {
63
56
    if (err == E_DEC_DIV_ZERO)
71
64
 
72
65
void Item_func_div::result_precision()
73
66
{
74
 
  uint32_t precision= min(args[0]->decimal_precision() + prec_increment,
75
 
                          (unsigned int)DECIMAL_MAX_PRECISION);
 
67
  uint32_t precision=cmin(args[0]->decimal_precision() + prec_increment,
 
68
                     (unsigned int)DECIMAL_MAX_PRECISION);
76
69
  /* Integer operations keep unsigned_flag if one of arguments is unsigned */
77
70
  if (result_type() == INT_RESULT)
78
71
    unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
79
72
  else
80
73
    unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
81
 
 
82
 
  decimals= min(args[0]->decimals + prec_increment, (unsigned int)DECIMAL_MAX_SCALE);
83
 
  max_length= class_decimal_precision_to_length(precision, decimals,
 
74
  decimals= cmin(args[0]->decimals + prec_increment, (unsigned int)DECIMAL_MAX_SCALE);
 
75
  max_length= my_decimal_precision_to_length(precision, decimals,
84
76
                                             unsigned_flag);
85
77
}
86
78
 
87
79
 
88
80
void Item_func_div::fix_length_and_dec()
89
81
{
90
 
  prec_increment= session->variables.div_precincrement;
 
82
  prec_increment= current_session->variables.div_precincrement;
91
83
  Item_num_op::fix_length_and_dec();
92
 
 
93
 
  switch(hybrid_type)
94
 
  {
 
84
  switch(hybrid_type) {
95
85
  case REAL_RESULT:
96
86
  {
97
 
    decimals= max(args[0]->decimals,args[1]->decimals)+prec_increment;
 
87
    decimals=cmax(args[0]->decimals,args[1]->decimals)+prec_increment;
98
88
    set_if_smaller(decimals, NOT_FIXED_DEC);
99
 
    max_length= args[0]->max_length - args[0]->decimals + decimals;
100
 
    uint32_t tmp= float_length(decimals);
 
89
    max_length=args[0]->max_length - args[0]->decimals + decimals;
 
90
    uint32_t tmp=float_length(decimals);
101
91
    set_if_smaller(max_length,tmp);
102
92
    break;
103
93
  }
115
105
  return;
116
106
}
117
107
 
118
 
} /* namespace drizzled */