← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/date.cc

  • Committer: Brian Aker
  • Date: 2010-12-18 02:06:13 UTC
  • Revision ID: brian@tangent.org-20101218020613-8lxhcvsy812bu960
Formatting + remove default from switch/case.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/date.cc
19
19
 */
20
20
 
21
21
#include "config.h"
 
22
#include <boost/lexical_cast.hpp>
 
23
 
22
24
#include "drizzled/field/date.h"
23
25
#include "drizzled/error.h"
24
26
#include "drizzled/table.h"
62
64
                         uint32_t len,
63
65
                         const CHARSET_INFO * const )
64
66
{
65
 
#ifdef NOTDEFINED
66
 
  long tmp;
67
 
  DRIZZLE_TIME l_time;
68
 
  int error;
69
 
  Session *session= table ? table->in_use : current_session;
70
 
  enum enum_drizzle_timestamp_type ret;
71
 
  if ((ret= str_to_datetime(from, len, &l_time,
72
 
                            (TIME_FUZZY_DATE |
73
 
                             (session->variables.sql_mode &
74
 
                              (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
75
 
                            &error)) <= DRIZZLE_TIMESTAMP_ERROR)
76
 
  {
77
 
    tmp= 0;
78
 
    error= 2;
79
 
  }
80
 
  else
81
 
  {
82
 
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
83
 
    if (!error && (ret != DRIZZLE_TIMESTAMP_DATE) &&
84
 
        (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
85
 
      error= 3;                                 // Datetime was cut (note)
86
 
  }
87
 
 
88
 
  if (error)
89
 
    set_datetime_warning(error == 3 ? DRIZZLE_ERROR::WARN_LEVEL_NOTE :
90
 
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
91
 
                         ER_WARN_DATA_TRUNCATED,
92
 
                         from, len, DRIZZLE_TIMESTAMP_DATE, 1);
93
 
 
94
 
  int3store(ptr, tmp);
95
 
#endif /* NOTDEFINED */
96
67
  /* 
97
68
   * Try to create a DateTime from the supplied string.  Throw an error
98
69
   * if unable to create a valid DateTime.  A DateTime is used so that
107
78
    return 2;
108
79
  }
109
80
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
110
 
  uint32_t int_value= (temporal.years() * 16 * 32) + (temporal.months() * 32) + temporal.days();
111
 
  int3store(ptr, int_value);
 
81
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
 
82
  int4store(ptr, int_value);
112
83
  return 0;
113
84
}
114
85
 
139
110
  DateTime temporal;
140
111
  if (! temporal.from_int64_t(from))
141
112
  {
142
 
    /* Convert the integer to a string using stringstream */
143
 
    std::stringstream ss;
144
 
    std::string tmp;
145
 
    ss << from; ss >> tmp;
 
113
    /* Convert the integer to a string using boost::lexical_cast */
 
114
    std::string tmp(boost::lexical_cast<std::string>(from)); 
146
115
 
147
116
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp.c_str());
148
117
    return 2;
149
118
  }
150
119
 
151
120
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
152
 
  uint32_t int_value= (temporal.years() * 16 * 32) + (temporal.months() * 32) + temporal.days();
153
 
  int3store(ptr, int_value);
 
121
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
 
122
  int4store(ptr, int_value);
154
123
  return 0;
155
124
}
156
125
 
162
131
  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
163
132
      time_type == DRIZZLE_TIMESTAMP_DATETIME)
164
133
  {
165
 
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
 
134
    tmp= ltime->year*10000 + ltime->month*100 + ltime->day;
166
135
    if (check_date(ltime, tmp != 0,
167
136
                   (TIME_FUZZY_DATE |
168
137
                    (current_session->variables.sql_mode &
192
161
    error= 1;
193
162
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
194
163
  }
195
 
  int3store(ptr,tmp);
 
164
  int4store(ptr,tmp);
196
165
  return error;
197
166
}
198
167
 
207
176
 
208
177
  ASSERT_COLUMN_MARKED_FOR_READ;
209
178
 
210
 
  j= uint3korr(ptr);
211
 
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
 
179
  j= uint4korr(ptr);
212
180
 
213
181
  return (int64_t) j;
214
182
}
215
183
 
216
 
String *Field_date::val_str(String *val_buffer,
217
 
                               String *)
 
184
String *Field_date::val_str(String *val_buffer, String *)
218
185
{
219
186
  val_buffer->alloc(field_length);
220
187
  val_buffer->length(field_length);
221
 
  uint32_t tmp=(uint32_t) uint3korr(ptr);
222
 
  int part;
 
188
  uint32_t tmp=(uint32_t) uint4korr(ptr);
 
189
  int32_t part;
223
190
  char *pos=(char*) val_buffer->ptr()+10;
224
191
 
225
192
  ASSERT_COLUMN_MARKED_FOR_READ;
226
193
 
227
194
  /* Open coded to get more speed */
228
195
  *pos--=0;                                     // End NULL
229
 
  part=(int) (tmp & 31);
230
 
  *pos--= (char) ('0'+part%10);
231
 
  *pos--= (char) ('0'+part/10);
232
 
  *pos--= '-';
233
 
  part=(int) (tmp >> 5 & 15);
234
 
  *pos--= (char) ('0'+part%10);
235
 
  *pos--= (char) ('0'+part/10);
236
 
  *pos--= '-';
237
 
  part=(int) (tmp >> 9);
 
196
  part=(int32_t) (tmp % 100);
 
197
  *pos--= (char) ('0'+part%10);
 
198
  *pos--= (char) ('0'+part/10);
 
199
  *pos--= '-';
 
200
  part=(int32_t) (tmp/100%100);
 
201
  *pos--= (char) ('0'+part%10);
 
202
  *pos--= (char) ('0'+part/10);
 
203
  *pos--= '-';
 
204
  part=(int32_t) (tmp/10000);
238
205
  *pos--= (char) ('0'+part%10); part/=10;
239
206
  *pos--= (char) ('0'+part%10); part/=10;
240
207
  *pos--= (char) ('0'+part%10); part/=10;
244
211
 
245
212
bool Field_date::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
246
213
{
247
 
  uint32_t tmp=(uint32_t) uint3korr(ptr);
248
 
  ltime->day=   tmp & 31;
249
 
  ltime->month= (tmp >> 5) & 15;
250
 
  ltime->year=  (tmp >> 9);
 
214
  uint32_t tmp=(uint32_t) uint4korr(ptr);
 
215
  ltime->day=           (int) (tmp%100);
 
216
  ltime->month=         (int) (tmp/100%100);
 
217
  ltime->year=          (int) (tmp/10000);
251
218
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
252
219
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
253
220
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
262
229
int Field_date::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
263
230
{
264
231
  uint32_t a,b;
265
 
  a=(uint32_t) uint3korr(a_ptr);
266
 
  b=(uint32_t) uint3korr(b_ptr);
 
232
  a=(uint32_t) uint4korr(a_ptr);
 
233
  b=(uint32_t) uint4korr(b_ptr);
267
234
  return (a < b) ? -1 : (a > b) ? 1 : 0;
268
235
}
269
236
 
270
237
void Field_date::sort_string(unsigned char *to,uint32_t )
271
238
{
272
 
  to[0] = ptr[2];
273
 
  to[1] = ptr[1];
274
 
  to[2] = ptr[0];
 
239
  to[0] = ptr[3];
 
240
  to[1] = ptr[2];
 
241
  to[2] = ptr[1];
 
242
  to[3] = ptr[0];
275
243
}
276
244
 
277
245
void Field_date::sql_type(String &res) const