← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/int64_t.cc

Removing global errbuff and cleaning up two remaining instances that referenced it.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/int64_t.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#ifdef USE_PRAGMA_IMPLEMENTATION
22
 
#pragma implementation                          // gcc: Class implementation
23
 
#endif
24
21
 
25
22
#include <drizzled/server_includes.h>
26
23
#include <drizzled/field/int64_t.h>
 
24
#include <drizzled/error.h>
 
25
#include <drizzled/table.h>
 
26
#include <drizzled/session.h>
 
27
 
27
28
 
28
29
/****************************************************************************
29
30
 Field type int64_t int (8 bytes)
35
36
  char *end;
36
37
  uint64_t tmp;
37
38
 
38
 
  tmp= cs->cset->strntoull10rnd(cs,from,len,unsigned_flag,&end,&error);
 
39
  tmp= cs->cset->strntoull10rnd(cs, from, len, false, &end,&error);
39
40
  if (error == MY_ERRNO_ERANGE)
40
41
  {
41
42
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
42
43
    error= 1;
43
44
  }
44
 
  else if (table->in_use->count_cuted_fields && 
 
45
  else if (table->in_use->count_cuted_fields &&
45
46
           check_int(cs, from, len, end, error))
46
47
    error= 1;
47
48
  else
64
65
  int64_t res;
65
66
 
66
67
  nr= rint(nr);
67
 
  if (unsigned_flag)
68
 
  {
69
 
    if (nr < 0)
70
 
    {
71
 
      res=0;
72
 
      error= 1;
73
 
    }
74
 
    else if (nr >= (double) UINT64_MAX)
75
 
    {
76
 
      res= ~(int64_t) 0;
77
 
      error= 1;
78
 
    }
79
 
    else
80
 
      res=(int64_t) (uint64_t) nr;
 
68
 
 
69
  if (nr <= (double) INT64_MIN)
 
70
  {
 
71
    res= INT64_MIN;
 
72
    error= (nr < (double) INT64_MIN);
 
73
  }
 
74
  else if (nr >= (double) (uint64_t) INT64_MAX)
 
75
  {
 
76
    res= INT64_MAX;
 
77
    error= (nr > (double) INT64_MAX);
81
78
  }
82
79
  else
83
 
  {
84
 
    if (nr <= (double) INT64_MIN)
85
 
    {
86
 
      res= INT64_MIN;
87
 
      error= (nr < (double) INT64_MIN);
88
 
    }
89
 
    else if (nr >= (double) (uint64_t) INT64_MAX)
90
 
    {
91
 
      res= INT64_MAX;
92
 
      error= (nr > (double) INT64_MAX);
93
 
    }
94
 
    else
95
 
      res=(int64_t) nr;
96
 
  }
 
80
    res=(int64_t) nr;
 
81
 
97
82
  if (error)
98
83
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
99
84
 
109
94
}
110
95
 
111
96
 
112
 
int Field_int64_t::store(int64_t nr, bool unsigned_val)
 
97
int Field_int64_t::store(int64_t nr, bool )
113
98
{
114
99
  int error= 0;
115
100
 
116
 
  if (nr < 0)                                   // Only possible error
117
 
  {
118
 
    /*
119
 
      if field is unsigned and value is signed (< 0) or
120
 
      if field is signed and value is unsigned we have an overflow
121
 
    */
122
 
    if (unsigned_flag != unsigned_val)
123
 
    {
124
 
      nr= unsigned_flag ? (uint64_t) 0 : (uint64_t) INT64_MAX;
125
 
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
126
 
      error= 1;
127
 
    }
128
 
  }
129
 
 
130
101
#ifdef WORDS_BIGENDIAN
131
102
  if (table->s->db_low_byte_first)
132
103
  {
151
122
#endif
152
123
    int64_tget(j,ptr);
153
124
  /* The following is open coded to avoid a bug in gcc 3.3 */
154
 
  if (unsigned_flag)
155
 
  {
156
 
    uint64_t tmp= (uint64_t) j;
157
 
    return uint64_t2double(tmp);
158
 
  }
159
125
  return (double) j;
160
126
}
161
127
 
174
140
 
175
141
 
176
142
String *Field_int64_t::val_str(String *val_buffer,
177
 
                                String *val_ptr __attribute__((unused)))
 
143
                                String *)
178
144
{
179
145
  const CHARSET_INFO * const cs= &my_charset_bin;
180
146
  uint32_t length;
189
155
#endif
190
156
    int64_tget(j,ptr);
191
157
 
192
 
  length=(uint) (cs->cset->int64_t10_to_str)(cs,to,mlength,
193
 
                                        unsigned_flag ? 10 : -10, j);
 
158
  length=(uint32_t) (cs->cset->int64_t10_to_str)(cs,to,mlength, -10, j);
194
159
  val_buffer->length(length);
195
160
 
196
161
  return val_buffer;
197
162
}
198
163
 
199
 
 
200
 
bool Field_int64_t::send_binary(Protocol *protocol)
201
 
{
202
 
  return protocol->store_int64_t(Field_int64_t::val_int(), unsigned_flag);
203
 
}
204
 
 
205
 
 
206
164
int Field_int64_t::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
207
165
{
208
166
  int64_t a,b;
218
176
    int64_tget(a,a_ptr);
219
177
    int64_tget(b,b_ptr);
220
178
  }
221
 
  if (unsigned_flag)
222
 
    return ((uint64_t) a < (uint64_t) b) ? -1 :
223
 
    ((uint64_t) a > (uint64_t) b) ? 1 : 0;
224
179
  return (a < b) ? -1 : (a > b) ? 1 : 0;
225
180
}
226
181
 
227
 
void Field_int64_t::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
 
182
void Field_int64_t::sort_string(unsigned char *to,uint32_t )
228
183
{
229
184
#ifdef WORDS_BIGENDIAN
230
185
  if (!table->s->db_low_byte_first)
231
186
  {
232
 
    if (unsigned_flag)
233
 
      to[0] = ptr[0];
234
 
    else
235
 
      to[0] = (char) (ptr[0] ^ 128);            /* Revers signbit */
 
187
    to[0] = (char) (ptr[0] ^ 128);              /* Revers signbit */
236
188
    to[1]   = ptr[1];
237
189
    to[2]   = ptr[2];
238
190
    to[3]   = ptr[3];
244
196
  else
245
197
#endif
246
198
  {
247
 
    if (unsigned_flag)
248
 
      to[0] = ptr[7];
249
 
    else
250
 
      to[0] = (char) (ptr[7] ^ 128);            /* Revers signbit */
 
199
    to[0] = (char) (ptr[7] ^ 128);              /* Revers signbit */
251
200
    to[1]   = ptr[6];
252
201
    to[2]   = ptr[5];
253
202
    to[3]   = ptr[4];
263
212
{
264
213
  const CHARSET_INFO * const cs=res.charset();
265
214
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), "bigint"));
266
 
  add_unsigned(res);
267
 
}
268
 
 
269
 
 
270
 
/*
271
 
  Floating-point numbers
272
 
 */
273
 
 
274
 
unsigned char *
275
 
Field_real::pack(unsigned char *to, const unsigned char *from,
276
 
                 uint32_t max_length, bool low_byte_first)
277
 
{
278
 
  assert(max_length >= pack_length());
279
 
#ifdef WORDS_BIGENDIAN
280
 
  if (low_byte_first != table->s->db_low_byte_first)
281
 
  {
282
 
    const unsigned char *dptr= from + pack_length();
283
 
    while (dptr-- > from)
284
 
      *to++ = *dptr;
285
 
    return(to);
286
 
  }
287
 
  else
288
 
#endif
289
 
    return(Field::pack(to, from, max_length, low_byte_first));
290
 
}
291
 
 
292
 
const unsigned char *
293
 
Field_real::unpack(unsigned char *to, const unsigned char *from,
294
 
                   uint32_t param_data, bool low_byte_first)
295
 
{
296
 
#ifdef WORDS_BIGENDIAN
297
 
  if (low_byte_first != table->s->db_low_byte_first)
298
 
  {
299
 
    const unsigned char *dptr= from + pack_length();
300
 
    while (dptr-- > from)
301
 
      *to++ = *dptr;
302
 
    return(from + pack_length());
303
 
  }
304
 
  else
305
 
#endif
306
 
    return(Field::unpack(to, from, param_data, low_byte_first));
 
215
}
 
216
 
 
217
 
 
218
unsigned char *Field_int64_t::pack(unsigned char* to, const unsigned char *from,
 
219
                                         uint32_t,
 
220
#ifdef WORDS_BIGENDIAN
 
221
                                         bool low_byte_first
 
222
#else
 
223
                                         bool
 
224
#endif
 
225
)
 
226
{
 
227
  int64_t val;
 
228
#ifdef WORDS_BIGENDIAN
 
229
  if (table->s->db_low_byte_first)
 
230
     val = sint8korr(from);
 
231
  else
 
232
#endif
 
233
    int64_tget(val, from);
 
234
 
 
235
#ifdef WORDS_BIGENDIAN
 
236
  if (low_byte_first)
 
237
    int8store(to, val);
 
238
  else
 
239
#endif
 
240
    int64_tstore(to, val);
 
241
  return to + sizeof(val);
 
242
}
 
243
 
 
244
 
 
245
const unsigned char *Field_int64_t::unpack(unsigned char* to, const unsigned char *from, uint32_t,
 
246
#ifdef WORDS_BIGENDIAN
 
247
                                           bool low_byte_first
 
248
#else
 
249
                                           bool
 
250
#endif
 
251
)
 
252
{
 
253
  int64_t val;
 
254
#ifdef WORDS_BIGENDIAN
 
255
  if (low_byte_first)
 
256
    val = sint8korr(from);
 
257
  else
 
258
#endif
 
259
    int64_tget(val, from);
 
260
 
 
261
#ifdef WORDS_BIGENDIAN
 
262
  if (table->s->db_low_byte_first)
 
263
    int8store(to, val);
 
264
  else
 
265
#endif
 
266
    int64_tstore(to, val);
 
267
  return from + sizeof(val);
307
268
}
308
269