← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/date.cc

  • Committer: Monty Taylor
  • Date: 2009-08-12 06:25:19 UTC
  • mto: (1114.1.1 innodb-plugin-merge)
  • mto: This revision was merged to the branch mainline in revision 1183.
  • Revision ID: mordred@inaugust.com-20090812062519-cij02mrrunvnxblt
Tags: innodb-plugin-1.0.4
InnoDB Plugin 1.0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/date.cc
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include "config.h"
22
 
#include <boost/lexical_cast.hpp>
23
 
 
24
 
#include "drizzled/field/date.h"
25
 
#include "drizzled/error.h"
26
 
#include "drizzled/table.h"
27
 
#include "drizzled/temporal.h"
28
 
#include "drizzled/session.h"
29
 
#include "drizzled/time_functions.h"
30
 
 
31
 
#include <math.h>
32
 
 
33
 
#include <sstream>
34
 
#include <string>
35
 
 
36
 
namespace drizzled
37
 
{
38
 
 
 
21
 
 
22
#include <drizzled/server_includes.h>
 
23
#include <drizzled/field/date.h>
 
24
#include <drizzled/error.h>
 
25
#include <drizzled/table.h>
 
26
#include <drizzled/session.h>
 
27
 
 
28
#include CMATH_H
 
29
 
 
30
#if defined(CMATH_NAMESPACE)
 
31
using namespace CMATH_NAMESPACE;
 
32
#endif
39
33
 
40
34
/****************************************************************************
41
35
** Drizzle date type stored in 3 bytes
60
54
       nearly-identical class Field_date doesn't ever return 3 from its
61
55
       store function.
62
56
*/
 
57
 
63
58
int Field_date::store(const char *from,
64
59
                         uint32_t len,
65
 
                         const CHARSET_INFO * const )
66
 
{
67
 
  /* 
68
 
   * Try to create a DateTime from the supplied string.  Throw an error
69
 
   * if unable to create a valid DateTime.  A DateTime is used so that
70
 
   * automatic conversion from the higher-storage DateTime can be used
71
 
   * and matches on datetime format strings can occur.
72
 
   */
73
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
74
 
  DateTime temporal;
75
 
  if (! temporal.from_string(from, (size_t) len))
76
 
  {
77
 
    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), from);
78
 
    return 2;
79
 
  }
80
 
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
81
 
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
82
 
  int4store(ptr, int_value);
83
 
  return 0;
84
 
}
85
 
 
86
 
int Field_date::store(double from)
87
 
{
88
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
89
 
  if (from < 0.0 || from > 99991231235959.0)
90
 
  {
91
 
    /* Convert the double to a string using stringstream */
92
 
    std::stringstream ss;
93
 
    std::string tmp;
94
 
    ss.precision(18); /* 18 places should be fine for error display of double input. */
95
 
    ss << from; ss >> tmp;
96
 
 
97
 
    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), tmp.c_str());
98
 
    return 2;
99
 
  }
100
 
  return Field_date::store((int64_t) rint(from), false);
101
 
}
102
 
 
103
 
int Field_date::store(int64_t from, bool)
104
 
{
105
 
  /* 
106
 
   * Try to create a DateTime from the supplied integer.  Throw an error
107
 
   * if unable to create a valid DateTime.  
108
 
   */
109
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
110
 
  DateTime temporal;
111
 
  if (! temporal.from_int64_t(from))
112
 
  {
113
 
    /* Convert the integer to a string using boost::lexical_cast */
114
 
    std::string tmp(boost::lexical_cast<std::string>(from)); 
115
 
 
116
 
    my_error(ER_INVALID_DATE_VALUE, MYF(ME_FATALERROR), tmp.c_str());
117
 
    return 2;
118
 
  }
119
 
 
120
 
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
121
 
  uint32_t int_value= (temporal.years() * 10000) + (temporal.months() * 100) + temporal.days();
122
 
  int4store(ptr, int_value);
123
 
 
124
 
  return 0;
125
 
}
126
 
 
127
 
int Field_date::store_time(type::Time &ltime,
128
 
                           type::timestamp_t time_type)
 
60
                         const CHARSET_INFO * const cs __attribute__((unused)))
 
61
{
 
62
  long tmp;
 
63
  DRIZZLE_TIME l_time;
 
64
  int error;
 
65
  Session *session= table ? table->in_use : current_session;
 
66
  enum enum_drizzle_timestamp_type ret;
 
67
  if ((ret= str_to_datetime(from, len, &l_time,
 
68
                            (TIME_FUZZY_DATE |
 
69
                             (session->variables.sql_mode &
 
70
                              (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
 
71
                            &error)) <= DRIZZLE_TIMESTAMP_ERROR)
 
72
  {
 
73
    tmp= 0;
 
74
    error= 2;
 
75
  }
 
76
  else
 
77
  {
 
78
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
 
79
    if (!error && (ret != DRIZZLE_TIMESTAMP_DATE) &&
 
80
        (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
 
81
      error= 3;                                 // Datetime was cut (note)
 
82
  }
 
83
 
 
84
  if (error)
 
85
    set_datetime_warning(error == 3 ? DRIZZLE_ERROR::WARN_LEVEL_NOTE :
 
86
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
87
                         ER_WARN_DATA_TRUNCATED,
 
88
                         from, len, DRIZZLE_TIMESTAMP_DATE, 1);
 
89
 
 
90
  int3store(ptr, tmp);
 
91
  return error;
 
92
}
 
93
 
 
94
 
 
95
int Field_date::store(double nr)
 
96
{
 
97
  if (nr < 0.0 || nr > 99991231235959.0)
 
98
  {
 
99
    int3store(ptr,(int32_t) 0);
 
100
    set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
101
                         ER_WARN_DATA_TRUNCATED, nr, DRIZZLE_TIMESTAMP_DATE);
 
102
    return 1;
 
103
  }
 
104
  return Field_date::store((int64_t) rint(nr), false);
 
105
}
 
106
 
 
107
 
 
108
int Field_date::store(int64_t nr,
 
109
                         bool unsigned_val __attribute__((unused)))
 
110
{
 
111
  DRIZZLE_TIME l_time;
 
112
  int64_t tmp;
 
113
  int error;
 
114
  Session *session= table ? table->in_use : current_session;
 
115
  if (number_to_datetime(nr, &l_time,
 
116
                         (TIME_FUZZY_DATE |
 
117
                          (session->variables.sql_mode &
 
118
                           (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
 
119
                         &error) == INT64_C(-1))
 
120
  {
 
121
    tmp= 0L;
 
122
    error= 2;
 
123
  }
 
124
  else
 
125
    tmp= l_time.day + l_time.month*32 + l_time.year*16*32;
 
126
 
 
127
  if (!error && l_time.time_type != DRIZZLE_TIMESTAMP_DATE &&
 
128
      (l_time.hour || l_time.minute || l_time.second || l_time.second_part))
 
129
    error= 3;
 
130
 
 
131
  if (error)
 
132
    set_datetime_warning(error == 3 ? DRIZZLE_ERROR::WARN_LEVEL_NOTE :
 
133
                         DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
134
                         error == 2 ? 
 
135
                         ER_WARN_DATA_OUT_OF_RANGE : ER_WARN_DATA_TRUNCATED,
 
136
                         nr,DRIZZLE_TIMESTAMP_DATE, 1);
 
137
 
 
138
  int3store(ptr,tmp);
 
139
  return error;
 
140
}
 
141
 
 
142
 
 
143
int Field_date::store_time(DRIZZLE_TIME *ltime,
 
144
                              enum enum_drizzle_timestamp_type time_type)
129
145
{
130
146
  long tmp;
131
147
  int error= 0;
132
 
  if (time_type == type::DRIZZLE_TIMESTAMP_DATE || time_type == type::DRIZZLE_TIMESTAMP_DATETIME)
 
148
  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
 
149
      time_type == DRIZZLE_TIMESTAMP_DATETIME)
133
150
  {
134
 
    tmp= ltime.year*10000 + ltime.month*100 + ltime.day;
135
 
 
136
 
    Session *session= getTable() ? getTable()->in_use : current_session;
137
 
    type::cut_t cut_error= type::VALID;
138
 
    if (ltime.check(tmp != 0,
139
 
                     (TIME_FUZZY_DATE |
140
 
                      (session->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), cut_error))
 
151
    tmp=ltime->year*16*32+ltime->month*32+ltime->day;
 
152
    if (check_date(ltime, tmp != 0,
 
153
                   (TIME_FUZZY_DATE |
 
154
                    (current_session->variables.sql_mode &
 
155
                     (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), &error))
141
156
    {
142
 
      char buff[type::Time::MAX_STRING_LENGTH];
 
157
      char buff[MAX_DATE_STRING_REP_LENGTH];
143
158
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
144
 
      ltime.convert(str, type::DRIZZLE_TIMESTAMP_DATE);
 
159
      make_date((DATE_TIME_FORMAT *) 0, ltime, &str);
145
160
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
146
 
                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
 
161
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
147
162
    }
148
 
 
149
 
    error= static_cast<int>(cut_error);
150
 
 
151
 
    if (not error && ltime.time_type != type::DRIZZLE_TIMESTAMP_DATE &&
152
 
        (ltime.hour || ltime.minute || ltime.second || ltime.second_part))
 
163
    if (!error && ltime->time_type != DRIZZLE_TIMESTAMP_DATE &&
 
164
        (ltime->hour || ltime->minute || ltime->second || ltime->second_part))
153
165
    {
154
 
      char buff[type::Time::MAX_STRING_LENGTH];
 
166
      char buff[MAX_DATE_STRING_REP_LENGTH];
155
167
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
156
 
      ltime.convert(str);
 
168
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
157
169
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE,
158
170
                           ER_WARN_DATA_TRUNCATED,
159
 
                           str.ptr(), str.length(), type::DRIZZLE_TIMESTAMP_DATE, 1);
 
171
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATE, 1);
160
172
      error= 3;
161
173
    }
162
174
  }
166
178
    error= 1;
167
179
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
168
180
  }
169
 
 
170
 
  int4store(ptr,tmp);
171
 
 
 
181
  int3store(ptr,tmp);
172
182
  return error;
173
183
}
174
184
 
 
185
 
 
186
bool Field_date::send_binary(Protocol *protocol)
 
187
{
 
188
  DRIZZLE_TIME tm;
 
189
  Field_date::get_date(&tm,0);
 
190
  return protocol->store_date(&tm);
 
191
}
 
192
 
 
193
 
175
194
double Field_date::val_real(void)
176
195
{
177
196
  return (double) Field_date::val_int();
178
197
}
179
198
 
 
199
 
180
200
int64_t Field_date::val_int(void)
181
201
{
182
 
  uint32_t j;
183
 
 
184
 
  ASSERT_COLUMN_MARKED_FOR_READ;
185
 
 
186
 
  j= uint4korr(ptr);
187
 
 
 
202
  uint32_t j= uint3korr(ptr);
 
203
  j= (j % 32L)+(j / 32L % 16L)*100L + (j/(16L*32L))*10000L;
188
204
  return (int64_t) j;
189
205
}
190
206
 
191
 
String *Field_date::val_str(String *val_buffer, String *)
 
207
 
 
208
String *Field_date::val_str(String *val_buffer,
 
209
                               String *val_ptr __attribute__((unused)))
192
210
{
193
211
  val_buffer->alloc(field_length);
194
212
  val_buffer->length(field_length);
195
 
  uint32_t tmp=(uint32_t) uint4korr(ptr);
196
 
  int32_t part;
 
213
  uint32_t tmp=(uint32_t) uint3korr(ptr);
 
214
  int part;
197
215
  char *pos=(char*) val_buffer->ptr()+10;
198
216
 
199
 
  ASSERT_COLUMN_MARKED_FOR_READ;
200
 
 
201
217
  /* Open coded to get more speed */
202
218
  *pos--=0;                                     // End NULL
203
 
  part=(int32_t) (tmp % 100);
204
 
  *pos--= (char) ('0'+part%10);
205
 
  *pos--= (char) ('0'+part/10);
206
 
  *pos--= '-';
207
 
  part=(int32_t) (tmp/100%100);
208
 
  *pos--= (char) ('0'+part%10);
209
 
  *pos--= (char) ('0'+part/10);
210
 
  *pos--= '-';
211
 
  part=(int32_t) (tmp/10000);
 
219
  part=(int) (tmp & 31);
 
220
  *pos--= (char) ('0'+part%10);
 
221
  *pos--= (char) ('0'+part/10);
 
222
  *pos--= '-';
 
223
  part=(int) (tmp >> 5 & 15);
 
224
  *pos--= (char) ('0'+part%10);
 
225
  *pos--= (char) ('0'+part/10);
 
226
  *pos--= '-';
 
227
  part=(int) (tmp >> 9);
212
228
  *pos--= (char) ('0'+part%10); part/=10;
213
229
  *pos--= (char) ('0'+part%10); part/=10;
214
230
  *pos--= (char) ('0'+part%10); part/=10;
216
232
  return val_buffer;
217
233
}
218
234
 
219
 
bool Field_date::get_date(type::Time &ltime, uint32_t fuzzydate)
 
235
 
 
236
bool Field_date::get_date(DRIZZLE_TIME *ltime,uint32_t fuzzydate)
220
237
{
221
 
  uint32_t tmp=(uint32_t) uint4korr(ptr);
222
 
  ltime.day=            (int) (tmp%100);
223
 
  ltime.month=  (int) (tmp/100%100);
224
 
  ltime.year=           (int) (tmp/10000);
225
 
  ltime.time_type= type::DRIZZLE_TIMESTAMP_DATE;
226
 
  ltime.hour= ltime.minute= ltime.second= ltime.second_part= ltime.neg= 0;
227
 
 
228
 
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime.month || !ltime.day)) ?
 
238
  uint32_t tmp=(uint32_t) uint3korr(ptr);
 
239
  ltime->day=   tmp & 31;
 
240
  ltime->month= (tmp >> 5) & 15;
 
241
  ltime->year=  (tmp >> 9);
 
242
  ltime->time_type= DRIZZLE_TIMESTAMP_DATE;
 
243
  ltime->hour= ltime->minute= ltime->second= ltime->second_part= ltime->neg= 0;
 
244
  return ((!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ?
229
245
          1 : 0);
230
246
}
231
247
 
232
 
bool Field_date::get_time(type::Time &ltime)
 
248
 
 
249
bool Field_date::get_time(DRIZZLE_TIME *ltime)
233
250
{
234
 
  return Field_date::get_date(ltime ,0);
 
251
  return Field_date::get_date(ltime,0);
235
252
}
236
253
 
 
254
 
237
255
int Field_date::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
238
256
{
239
257
  uint32_t a,b;
240
 
  a=(uint32_t) uint4korr(a_ptr);
241
 
  b=(uint32_t) uint4korr(b_ptr);
 
258
  a=(uint32_t) uint3korr(a_ptr);
 
259
  b=(uint32_t) uint3korr(b_ptr);
242
260
  return (a < b) ? -1 : (a > b) ? 1 : 0;
243
261
}
244
262
 
245
 
void Field_date::sort_string(unsigned char *to,uint32_t )
 
263
 
 
264
void Field_date::sort_string(unsigned char *to,uint32_t length __attribute__((unused)))
246
265
{
247
 
  to[0] = ptr[3];
248
 
  to[1] = ptr[2];
249
 
  to[2] = ptr[1];
250
 
  to[3] = ptr[0];
 
266
  to[0] = ptr[2];
 
267
  to[1] = ptr[1];
 
268
  to[2] = ptr[0];
251
269
}
252
270
 
 
271
 
253
272
void Field_date::sql_type(String &res) const
254
273
{
255
274
  res.set_ascii(STRING_WITH_LEN("date"));
256
275
}
257
276
 
258
 
} /* namespace drizzled */