← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/long.cc

  • Committer: Monty Taylor
  • Date: 2008-09-16 00:00:48 UTC
  • mto: This revision was merged to the branch mainline in revision 391.
  • Revision ID: monty@inaugust.com-20080916000048-3rvrv3gv9l0ad3gs
Fixed copyright headers in drizzled/

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/long.cc
1
 
/* - mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2008 MySQL
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
21
24
 
22
25
#include <drizzled/server_includes.h>
23
26
#include <drizzled/field/long.h>
24
 
#include <drizzled/error.h>
25
 
#include CMATH_H
26
 
 
27
 
#if defined(CMATH_NAMESPACE)
28
 
using namespace CMATH_NAMESPACE;
29
 
#endif
30
27
 
31
28
/****************************************************************************
32
29
** long int
33
30
****************************************************************************/
34
31
 
35
 
int Field_long::store(const char *from,uint32_t len, const CHARSET_INFO * const cs)
 
32
int Field_long::store(const char *from,uint len, const CHARSET_INFO * const cs)
36
33
{
37
34
  long store_tmp;
38
35
  int error;
39
36
  int64_t rnd;
40
37
  
41
38
  error= get_int(cs, from, len, &rnd, UINT32_MAX, INT32_MIN, INT32_MAX);
42
 
  store_tmp= (long) rnd;
 
39
  store_tmp= unsigned_flag ? (long) (uint64_t) rnd : (long) rnd;
43
40
#ifdef WORDS_BIGENDIAN
44
41
  if (table->s->db_low_byte_first)
45
42
  {
57
54
  int error= 0;
58
55
  int32_t res;
59
56
  nr=rint(nr);
60
 
 
61
 
  if (nr < (double) INT32_MIN)
62
 
  {
63
 
    res=(int32_t) INT32_MIN;
64
 
    error= 1;
65
 
  }
66
 
  else if (nr > (double) INT32_MAX)
67
 
  {
68
 
    res=(int32_t) INT32_MAX;
69
 
    error= 1;
 
57
  if (unsigned_flag)
 
58
  {
 
59
    if (nr < 0)
 
60
    {
 
61
      res=0;
 
62
      error= 1;
 
63
    }
 
64
    else if (nr > (double) UINT32_MAX)
 
65
    {
 
66
      res= INT32_MAX;
 
67
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
68
      error= 1;
 
69
    }
 
70
    else
 
71
      res=(int32_t) (uint32_t) nr;
70
72
  }
71
73
  else
72
 
    res=(int32_t) (int64_t) nr;
73
 
 
 
74
  {
 
75
    if (nr < (double) INT32_MIN)
 
76
    {
 
77
      res=(int32_t) INT32_MIN;
 
78
      error= 1;
 
79
    }
 
80
    else if (nr > (double) INT32_MAX)
 
81
    {
 
82
      res=(int32_t) INT32_MAX;
 
83
      error= 1;
 
84
    }
 
85
    else
 
86
      res=(int32_t) (int64_t) nr;
 
87
  }
74
88
  if (error)
75
89
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
76
90
 
91
105
  int error= 0;
92
106
  int32_t res;
93
107
 
94
 
  if (nr < 0 && unsigned_val)
95
 
    nr= ((int64_t) INT32_MAX) + 1;           // Generate overflow
96
 
  if (nr < (int64_t) INT32_MIN) 
97
 
  {
98
 
    res=(int32_t) INT32_MIN;
99
 
    error= 1;
100
 
  }
101
 
  else if (nr > (int64_t) INT32_MAX)
102
 
  {
103
 
    res=(int32_t) INT32_MAX;
104
 
    error= 1;
 
108
  if (unsigned_flag)
 
109
  {
 
110
    if (nr < 0 && !unsigned_val)
 
111
    {
 
112
      res=0;
 
113
      error= 1;
 
114
    }
 
115
    else if (nr > INT32_MAX)
 
116
    {
 
117
      res= INT32_MAX;
 
118
      error= 1;
 
119
    }
 
120
    else
 
121
      res=(int32_t) (uint32_t) nr;
105
122
  }
106
123
  else
107
 
    res=(int32_t) nr;
108
 
 
 
124
  {
 
125
    if (nr < 0 && unsigned_val)
 
126
      nr= ((int64_t) INT32_MAX) + 1;           // Generate overflow
 
127
    if (nr < (int64_t) INT32_MIN) 
 
128
    {
 
129
      res=(int32_t) INT32_MIN;
 
130
      error= 1;
 
131
    }
 
132
    else if (nr > (int64_t) INT32_MAX)
 
133
    {
 
134
      res=(int32_t) INT32_MAX;
 
135
      error= 1;
 
136
    }
 
137
    else
 
138
      res=(int32_t) nr;
 
139
  }
109
140
  if (error)
110
141
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
111
142
 
130
161
  else
131
162
#endif
132
163
    longget(j,ptr);
133
 
  return (double) j;
 
164
  return unsigned_flag ? (double) (uint32_t) j : (double) j;
134
165
}
135
166
 
136
167
int64_t Field_long::val_int(void)
137
168
{
138
169
  int32_t j;
139
 
  /* See the comment in Field_long::store(int64_t) */
140
 
  assert(table->in_use == current_session);
 
170
  /* See the comment in Field_long::store(long long) */
 
171
  assert(table->in_use == current_thd);
141
172
#ifdef WORDS_BIGENDIAN
142
173
  if (table->s->db_low_byte_first)
143
174
    j=sint4korr(ptr);
144
175
  else
145
176
#endif
146
177
    longget(j,ptr);
147
 
  return (int64_t) j;
 
178
  return unsigned_flag ? (int64_t) (uint32_t) j : (int64_t) j;
148
179
}
149
180
 
150
181
String *Field_long::val_str(String *val_buffer,
151
182
                            String *val_ptr __attribute__((unused)))
152
183
{
153
184
  const CHARSET_INFO * const cs= &my_charset_bin;
154
 
  uint32_t length;
155
 
  uint32_t mlength=cmax(field_length+1,12*cs->mbmaxlen);
 
185
  uint length;
 
186
  uint mlength=max(field_length+1,12*cs->mbmaxlen);
156
187
  val_buffer->alloc(mlength);
157
188
  char *to=(char*) val_buffer->ptr();
158
189
  int32_t j;
163
194
#endif
164
195
    longget(j,ptr);
165
196
 
166
 
  length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
 
197
  if (unsigned_flag)
 
198
    length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32_t)j);
 
199
  else
 
200
    length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
167
201
  val_buffer->length(length);
168
202
 
169
203
  return val_buffer;
175
209
  return protocol->store_long(Field_long::val_int());
176
210
}
177
211
 
178
 
int Field_long::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
212
int Field_long::cmp(const uchar *a_ptr, const uchar *b_ptr)
179
213
{
180
214
  int32_t a,b;
181
215
#ifdef WORDS_BIGENDIAN
190
224
    longget(a,a_ptr);
191
225
    longget(b,b_ptr);
192
226
  }
193
 
 
 
227
  if (unsigned_flag)
 
228
    return ((uint32_t) a < (uint32_t) b) ? -1 : ((uint32_t) a > (uint32_t) b) ? 1 : 0;
194
229
  return (a < b) ? -1 : (a > b) ? 1 : 0;
195
230
}
196
231
 
197
 
void Field_long::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
 
232
void Field_long::sort_string(uchar *to,uint length __attribute__((unused)))
198
233
{
199
234
#ifdef WORDS_BIGENDIAN
200
235
  if (!table->s->db_low_byte_first)
201
236
  {
202
 
    to[0] = (char) (ptr[0] ^ 128);              /* Revers signbit */
 
237
    if (unsigned_flag)
 
238
      to[0] = ptr[0];
 
239
    else
 
240
      to[0] = (char) (ptr[0] ^ 128);            /* Revers signbit */
203
241
    to[1]   = ptr[1];
204
242
    to[2]   = ptr[2];
205
243
    to[3]   = ptr[3];
207
245
  else
208
246
#endif
209
247
  {
210
 
    to[0] = (char) (ptr[3] ^ 128);              /* Revers signbit */
 
248
    if (unsigned_flag)
 
249
      to[0] = ptr[3];
 
250
    else
 
251
      to[0] = (char) (ptr[3] ^ 128);            /* Revers signbit */
211
252
    to[1]   = ptr[2];
212
253
    to[2]   = ptr[1];
213
254
    to[3]   = ptr[0];
219
260
{
220
261
  const CHARSET_INFO * const cs=res.charset();
221
262
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), "int"));
 
263
  add_unsigned(res);
222
264
}
223
265