← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/func.cc

  • Committer: Lee Bieber
  • Date: 2008-11-21 21:52:58 UTC
  • mto: (590.2.7 devel)
  • mto: This revision was merged to the branch mainline in revision 603.
  • Revision ID: lb4072@soe-t2000-8-20081121215258-s86ky54w5r676o4q
changes to get build working on Solaris

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/func.cc
 
1
/** Copyright (C) 2000-2003 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
/**
 
18
  @file
 
19
 
 
20
  @brief
 
21
  This file defines all numerical functions
 
22
*/
 
23
 
 
24
#include <drizzled/server_includes.h>
 
25
#include <drizzled/functions/func.h>
 
26
#include <drizzled/session.h>
 
27
#include <mysys/my_bit.h>
 
28
#include <drizzled/slave.h>
 
29
#include <drizzled/error.h>
 
30
 
 
31
bool check_reserved_words(LEX_STRING *name)
 
32
{
 
33
  if (!my_strcasecmp(system_charset_info, name->str, "GLOBAL") ||
 
34
      !my_strcasecmp(system_charset_info, name->str, "LOCAL") ||
 
35
      !my_strcasecmp(system_charset_info, name->str, "SESSION"))
 
36
    return true;
 
37
  return false;
 
38
}
 
39
 
 
40
 
 
41
/**
 
42
  @return
 
43
    true if item is a constant
 
44
*/
 
45
 
 
46
bool
 
47
eval_const_cond(COND *cond)
 
48
{
 
49
  return ((Item_func*) cond)->val_int() ? true : false;
 
50
}
 
51
 
 
52
 
 
53
void Item_func::fix_num_length_and_dec()
 
54
{
 
55
  uint32_t fl_length= 0;
 
56
  decimals=0;
 
57
  for (uint32_t i=0 ; i < arg_count ; i++)
 
58
  {
 
59
    set_if_bigger(decimals,args[i]->decimals);
 
60
    set_if_bigger(fl_length, args[i]->max_length);
 
61
  }
 
62
  max_length=float_length(decimals);
 
63
  if (fl_length > max_length)
 
64
  {
 
65
    decimals= NOT_FIXED_DEC;
 
66
    max_length= float_length(NOT_FIXED_DEC);
 
67
  }
 
68
}
 
69
 
 
70
/**
 
71
  Set max_length/decimals of function if function is fixed point and
 
72
  result length/precision depends on argument ones.
 
73
*/
 
74
 
 
75
void Item_func::count_decimal_length()
 
76
{
 
77
  int max_int_part= 0;
 
78
  decimals= 0;
 
79
  unsigned_flag= 1;
 
80
  for (uint32_t i=0 ; i < arg_count ; i++)
 
81
  {
 
82
    set_if_bigger(decimals, args[i]->decimals);
 
83
    set_if_bigger(max_int_part, args[i]->decimal_int_part());
 
84
    set_if_smaller(unsigned_flag, args[i]->unsigned_flag);
 
85
  }
 
86
  int precision= cmin(max_int_part + decimals, DECIMAL_MAX_PRECISION);
 
87
  max_length= my_decimal_precision_to_length(precision, decimals,
 
88
                                             unsigned_flag);
 
89
}
 
90
 
 
91
 
 
92
/**
 
93
  Set max_length of if it is maximum length of its arguments.
 
94
*/
 
95
 
 
96
void Item_func::count_only_length()
 
97
{
 
98
  max_length= 0;
 
99
  unsigned_flag= 0;
 
100
  for (uint32_t i=0 ; i < arg_count ; i++)
 
101
  {
 
102
    set_if_bigger(max_length, args[i]->max_length);
 
103
    set_if_bigger(unsigned_flag, args[i]->unsigned_flag);
 
104
  }
 
105
}
 
106
 
 
107
 
 
108
/**
 
109
  Set max_length/decimals of function if function is floating point and
 
110
  result length/precision depends on argument ones.
 
111
*/
 
112
 
 
113
void Item_func::count_real_length()
 
114
{
 
115
  uint32_t length= 0;
 
116
  decimals= 0;
 
117
  max_length= 0;
 
118
  for (uint32_t i=0 ; i < arg_count ; i++)
 
119
  {
 
120
    if (decimals != NOT_FIXED_DEC)
 
121
    {
 
122
      set_if_bigger(decimals, args[i]->decimals);
 
123
      set_if_bigger(length, (args[i]->max_length - args[i]->decimals));
 
124
    }
 
125
    set_if_bigger(max_length, args[i]->max_length);
 
126
  }
 
127
  if (decimals != NOT_FIXED_DEC)
 
128
  {
 
129
    max_length= length;
 
130
    length+= decimals;
 
131
    if (length < max_length)  // If previous operation gave overflow
 
132
      max_length= UINT32_MAX;
 
133
    else
 
134
      max_length= length;
 
135
  }
 
136
}
 
137
 
 
138
 
 
139
 
 
140
void Item_func::signal_divide_by_null()
 
141
{
 
142
  Session *session= current_session;
 
143
  push_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
 
144
  null_value= 1;
 
145
}
 
146
 
 
147
 
 
148
Item *Item_func::get_tmp_table_item(Session *session)
 
149
{
 
150
  if (!with_sum_func && !const_item() && functype() != SUSERVAR_FUNC)
 
151
    return new Item_field(result_field);
 
152
  return copy_or_same(session);
 
153
}
 
154
 
 
155
 
 
156
/** Get the value of a variable as a double. */
 
157
 
 
158
double user_var_entry::val_real(bool *null_value)
 
159
{
 
160
  if ((*null_value= (value == 0)))
 
161
    return 0.0;
 
162
 
 
163
  switch (type) {
 
164
  case REAL_RESULT:
 
165
    return *(double*) value;
 
166
  case INT_RESULT:
 
167
    return (double) *(int64_t*) value;
 
168
  case DECIMAL_RESULT:
 
169
  {
 
170
    double result;
 
171
    my_decimal2double(E_DEC_FATAL_ERROR, (my_decimal *)value, &result);
 
172
    return result;
 
173
  }
 
174
  case STRING_RESULT:
 
175
    return my_atof(value);                      // This is null terminated
 
176
  case ROW_RESULT:
 
177
    assert(1);                          // Impossible
 
178
    break;
 
179
  }
 
180
  return 0.0;                                   // Impossible
 
181
}
 
182
 
 
183
 
 
184
/** Get the value of a variable as an integer. */
 
185
 
 
186
int64_t user_var_entry::val_int(bool *null_value) const
 
187
{
 
188
  if ((*null_value= (value == 0)))
 
189
    return 0L;
 
190
 
 
191
  switch (type) {
 
192
  case REAL_RESULT:
 
193
    return (int64_t) *(double*) value;
 
194
  case INT_RESULT:
 
195
    return *(int64_t*) value;
 
196
  case DECIMAL_RESULT:
 
197
  {
 
198
    int64_t result;
 
199
    my_decimal2int(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, &result);
 
200
    return result;
 
201
  }
 
202
  case STRING_RESULT:
 
203
  {
 
204
    int error;
 
205
    return my_strtoll10(value, (char**) 0, &error);// String is null terminated
 
206
  }
 
207
  case ROW_RESULT:
 
208
    assert(1);                          // Impossible
 
209
    break;
 
210
  }
 
211
  return 0L;                                    // Impossible
 
212
}
 
213
 
 
214
 
 
215
/** Get the value of a variable as a string. */
 
216
 
 
217
String *user_var_entry::val_str(bool *null_value, String *str,
 
218
                                uint32_t decimals)
 
219
{
 
220
  if ((*null_value= (value == 0)))
 
221
    return (String*) 0;
 
222
 
 
223
  switch (type) {
 
224
  case REAL_RESULT:
 
225
    str->set_real(*(double*) value, decimals, &my_charset_bin);
 
226
    break;
 
227
  case INT_RESULT:
 
228
    if (!unsigned_flag)
 
229
      str->set(*(int64_t*) value, &my_charset_bin);
 
230
    else
 
231
      str->set(*(uint64_t*) value, &my_charset_bin);
 
232
    break;
 
233
  case DECIMAL_RESULT:
 
234
    my_decimal2string(E_DEC_FATAL_ERROR, (my_decimal *)value, 0, 0, 0, str);
 
235
    break;
 
236
  case STRING_RESULT:
 
237
    if (str->copy(value, length, collation.collation))
 
238
      str= 0;                                   // EOM error
 
239
  case ROW_RESULT:
 
240
    assert(1);                          // Impossible
 
241
    break;
 
242
  }
 
243
  return(str);
 
244
}
 
245
 
 
246
/** Get the value of a variable as a decimal. */
 
247
 
 
248
my_decimal *user_var_entry::val_decimal(bool *null_value, my_decimal *val)
 
249
{
 
250
  if ((*null_value= (value == 0)))
 
251
    return 0;
 
252
 
 
253
  switch (type) {
 
254
  case REAL_RESULT:
 
255
    double2my_decimal(E_DEC_FATAL_ERROR, *(double*) value, val);
 
256
    break;
 
257
  case INT_RESULT:
 
258
    int2my_decimal(E_DEC_FATAL_ERROR, *(int64_t*) value, 0, val);
 
259
    break;
 
260
  case DECIMAL_RESULT:
 
261
    val= (my_decimal *)value;
 
262
    break;
 
263
  case STRING_RESULT:
 
264
    str2my_decimal(E_DEC_FATAL_ERROR, value, length, collation.collation, val);
 
265
    break;
 
266
  case ROW_RESULT:
 
267
    assert(1);                          // Impossible
 
268
    break;
 
269
  }
 
270
  return(val);
 
271
}