← 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-11-16 06:29:53 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116062953-ivdltjmfe009b5fr
Moved stuff into item/

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/long.cc
19
19
 */
20
20
 
21
21
 
22
 
#include "config.h"
 
22
#include <drizzled/server_includes.h>
23
23
#include <drizzled/field/long.h>
24
24
#include <drizzled/error.h>
25
 
#include <drizzled/table.h>
26
 
#include <drizzled/session.h>
27
 
 
28
 
#include <math.h>
29
 
 
30
 
#include <algorithm>
31
 
 
32
 
using namespace std;
33
 
 
34
 
namespace drizzled
35
 
{
 
25
#include CMATH_H
 
26
 
 
27
#if defined(CMATH_NAMESPACE)
 
28
using namespace CMATH_NAMESPACE;
 
29
#endif
36
30
 
37
31
/****************************************************************************
38
32
** long int
43
37
  long store_tmp;
44
38
  int error;
45
39
  int64_t rnd;
46
 
 
47
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
48
 
 
 
40
  
49
41
  error= get_int(cs, from, len, &rnd, UINT32_MAX, INT32_MIN, INT32_MAX);
50
42
  store_tmp= (long) rnd;
51
43
#ifdef WORDS_BIGENDIAN
52
 
  if (getTable()->s->db_low_byte_first)
 
44
  if (table->s->db_low_byte_first)
53
45
  {
54
46
    int4store(ptr, store_tmp);
55
47
  }
66
58
  int32_t res;
67
59
  nr=rint(nr);
68
60
 
69
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
70
 
 
71
61
  if (nr < (double) INT32_MIN)
72
62
  {
73
63
    res=(int32_t) INT32_MIN;
85
75
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
86
76
 
87
77
#ifdef WORDS_BIGENDIAN
88
 
  if (getTable()->s->db_low_byte_first)
 
78
  if (table->s->db_low_byte_first)
89
79
  {
90
80
    int4store(ptr,res);
91
81
  }
101
91
  int error= 0;
102
92
  int32_t res;
103
93
 
104
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
105
 
 
106
94
  if (nr < 0 && unsigned_val)
107
95
    nr= ((int64_t) INT32_MAX) + 1;           // Generate overflow
108
 
  if (nr < (int64_t) INT32_MIN)
 
96
  if (nr < (int64_t) INT32_MIN) 
109
97
  {
110
98
    res=(int32_t) INT32_MIN;
111
99
    error= 1;
122
110
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
123
111
 
124
112
#ifdef WORDS_BIGENDIAN
125
 
  if (getTable()->s->db_low_byte_first)
 
113
  if (table->s->db_low_byte_first)
126
114
  {
127
115
    int4store(ptr,res);
128
116
  }
136
124
double Field_long::val_real(void)
137
125
{
138
126
  int32_t j;
139
 
 
140
 
  ASSERT_COLUMN_MARKED_FOR_READ;
141
 
 
142
127
#ifdef WORDS_BIGENDIAN
143
 
  if (getTable()->s->db_low_byte_first)
 
128
  if (table->s->db_low_byte_first)
144
129
    j=sint4korr(ptr);
145
130
  else
146
131
#endif
151
136
int64_t Field_long::val_int(void)
152
137
{
153
138
  int32_t j;
154
 
 
155
 
  ASSERT_COLUMN_MARKED_FOR_READ;
156
 
 
157
139
  /* See the comment in Field_long::store(int64_t) */
 
140
  assert(table->in_use == current_session);
158
141
#ifdef WORDS_BIGENDIAN
159
 
  if (getTable()->s->db_low_byte_first)
 
142
  if (table->s->db_low_byte_first)
160
143
    j=sint4korr(ptr);
161
144
  else
162
145
#endif
165
148
}
166
149
 
167
150
String *Field_long::val_str(String *val_buffer,
168
 
                            String *)
 
151
                            String *val_ptr __attribute__((unused)))
169
152
{
170
153
  const CHARSET_INFO * const cs= &my_charset_bin;
171
154
  uint32_t length;
172
 
  uint32_t mlength= max(field_length+1,12*cs->mbmaxlen);
 
155
  uint32_t mlength=cmax(field_length+1,12*cs->mbmaxlen);
173
156
  val_buffer->alloc(mlength);
174
157
  char *to=(char*) val_buffer->ptr();
175
158
  int32_t j;
176
 
 
177
 
  ASSERT_COLUMN_MARKED_FOR_READ;
178
 
 
179
159
#ifdef WORDS_BIGENDIAN
180
 
  if (getTable()->s->db_low_byte_first)
 
160
  if (table->s->db_low_byte_first)
181
161
    j=sint4korr(ptr);
182
162
  else
183
163
#endif
189
169
  return val_buffer;
190
170
}
191
171
 
 
172
 
 
173
bool Field_long::send_binary(Protocol *protocol)
 
174
{
 
175
  return protocol->store_long(Field_long::val_int());
 
176
}
 
177
 
192
178
int Field_long::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
193
179
{
194
180
  int32_t a,b;
195
181
#ifdef WORDS_BIGENDIAN
196
 
  if (getTable()->s->db_low_byte_first)
 
182
  if (table->s->db_low_byte_first)
197
183
  {
198
184
    a=sint4korr(a_ptr);
199
185
    b=sint4korr(b_ptr);
208
194
  return (a < b) ? -1 : (a > b) ? 1 : 0;
209
195
}
210
196
 
211
 
void Field_long::sort_string(unsigned char *to,uint32_t )
 
197
void Field_long::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
212
198
{
213
199
#ifdef WORDS_BIGENDIAN
214
 
  if (!getTable()->s->db_low_byte_first)
 
200
  if (!table->s->db_low_byte_first)
215
201
  {
216
202
    to[0] = (char) (ptr[0] ^ 128);              /* Revers signbit */
217
203
    to[1]   = ptr[1];
235
221
  res.length(cs->cset->snprintf(cs,(char*) res.ptr(),res.alloced_length(), "int"));
236
222
}
237
223
 
238
 
unsigned char *Field_long::pack(unsigned char* to, const unsigned char *from,
239
 
                                         uint32_t,
240
 
#ifdef WORDS_BIGENDIAN
241
 
                                         bool low_byte_first
242
 
#else
243
 
                                         bool
244
 
#endif
245
 
)
246
 
{
247
 
  int32_t val;
248
 
#ifdef WORDS_BIGENDIAN
249
 
  if (getTable()->s->db_low_byte_first)
250
 
    val = sint4korr(from);
251
 
  else
252
 
#endif
253
 
    longget(val, from);
254
 
 
255
 
#ifdef WORDS_BIGENDIAN
256
 
  if (low_byte_first)
257
 
    int4store(to, val);
258
 
  else
259
 
#endif
260
 
    longstore(to, val);
261
 
  return to + sizeof(val);
262
 
}
263
 
 
264
 
 
265
 
const unsigned char *Field_long::unpack(unsigned char* to, const unsigned char *from, uint32_t,
266
 
#ifdef WORDS_BIGENDIAN
267
 
                                           bool low_byte_first
268
 
#else
269
 
                                           bool
270
 
#endif
271
 
)
272
 
{
273
 
  int32_t val;
274
 
#ifdef WORDS_BIGENDIAN
275
 
  if (low_byte_first)
276
 
    val = sint4korr(from);
277
 
  else
278
 
#endif
279
 
    longget(val, from);
280
 
 
281
 
#ifdef WORDS_BIGENDIAN
282
 
  if (getTable()->s->db_low_byte_first)
283
 
    int4store(to, val);
284
 
  else
285
 
#endif
286
 
    longstore(to, val);
287
 
  return from + sizeof(val);
288
 
}
289
 
 
290
 
} /* namespace drizzled */