← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/datetime.cc

  • Committer: Monty Taylor
  • Date: 2008-09-15 00:46:33 UTC
  • mfrom: (383.1.55 client-split)
  • Revision ID: monty@inaugust.com-20080915004633-fmjw27fi41cxs35w
Merged from client-split.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/datetime.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
 
#include "config.h"
22
 
#include "drizzled/field/datetime.h"
23
 
#include "drizzled/error.h"
24
 
#include "drizzled/table.h"
25
 
#include "drizzled/temporal.h"
26
 
#include "drizzled/session.h"
27
 
 
28
 
#include <math.h>
29
 
 
30
 
#include <sstream>
31
 
#include <string>
32
 
 
33
 
 
34
 
namespace drizzled
35
 
{
 
21
#ifdef USE_PRAGMA_IMPLEMENTATION
 
22
#pragma implementation                          // gcc: Class implementation
 
23
#endif
 
24
 
 
25
#include <drizzled/server_includes.h>
 
26
#include <drizzled/field/datetime.h>
36
27
 
37
28
/****************************************************************************
38
29
** datetime type
39
30
** In string context: YYYY-MM-DD HH:MM:DD
40
31
** In number context: YYYYMMDDHHMMDD
 
32
** Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte int.
41
33
****************************************************************************/
42
34
 
43
35
int Field_datetime::store(const char *from,
44
 
                          uint32_t len,
45
 
                          const CHARSET_INFO * const )
46
 
{
47
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
48
 
  /* 
49
 
   * Try to create a DateTime from the supplied string.  Throw an error
50
 
   * if unable to create a valid DateTime.  
51
 
   */
52
 
  DateTime temporal;
53
 
  if (! temporal.from_string(from, (size_t) len))
54
 
  {
55
 
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), from);
56
 
    return 2;
57
 
  }
58
 
  /* Create the stored integer format. @TODO This should go away. Should be up to engine... */
59
 
  int64_t int_value;
60
 
  temporal.to_int64_t(&int_value);
61
 
 
62
 
#ifdef WORDS_BIGENDIAN
63
 
  if (getTable() && getTable()->s->db_low_byte_first)
64
 
  {
65
 
    int8store(ptr, int_value);
66
 
  }
67
 
  else
68
 
#endif
69
 
    int64_tstore(ptr, int_value);
70
 
  return 0;
71
 
}
72
 
 
73
 
int Field_datetime::store(double from)
74
 
{
75
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
76
 
  if (from < 0.0 || from > 99991231235959.0)
77
 
  {
78
 
    /* Convert the double to a string using stringstream */
79
 
    std::stringstream ss;
80
 
    std::string tmp;
81
 
    ss.precision(18); /* 18 places should be fine for error display of double input. */
82
 
    ss << from; ss >> tmp;
83
 
 
84
 
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp.c_str());
85
 
    return 2;
86
 
  }
87
 
  return Field_datetime::store((int64_t) rint(from), false);
88
 
}
89
 
 
90
 
int Field_datetime::store(int64_t from, bool)
91
 
{
92
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
93
 
  /* 
94
 
   * Try to create a DateTime from the supplied integer.  Throw an error
95
 
   * if unable to create a valid DateTime.  
96
 
   */
97
 
  DateTime temporal;
98
 
  if (! temporal.from_int64_t(from))
99
 
  {
100
 
    /* Convert the integer to a string using stringstream */
101
 
    std::stringstream ss;
102
 
    std::string tmp;
103
 
    ss << from; ss >> tmp;
104
 
 
105
 
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp.c_str());
106
 
    return 2;
107
 
  }
108
 
 
109
 
  /* 
110
 
   * Because "from" may be a silly MySQL-like "datetime number" (like, oh, 101)
111
 
   * we must here get the value of the DateTime as its *real* int64_t, after
112
 
   * the conversion above has been done...yuck. God, save us.
113
 
   */
114
 
  int64_t int_value;
115
 
  temporal.to_int64_t(&int_value);
116
 
 
117
 
#ifdef WORDS_BIGENDIAN
118
 
  if (getTable() && getTable()->s->db_low_byte_first)
119
 
  {
120
 
    int8store(ptr, int_value);
121
 
  }
122
 
  else
123
 
#endif
124
 
    int64_tstore(ptr, int_value);
125
 
  return 0;
126
 
}
127
 
 
128
 
int Field_datetime::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
129
 
{
130
 
  DateTime temporal;
131
 
 
132
 
  temporal.set_years(ltime->year);
133
 
  temporal.set_months(ltime->month);
134
 
  temporal.set_days(ltime->day);
135
 
  temporal.set_hours(ltime->hour);
136
 
  temporal.set_minutes(ltime->minute);
137
 
  temporal.set_seconds(ltime->second);
138
 
 
139
 
  if (! temporal.is_valid())
140
 
  {
141
 
    char tmp_string[MAX_DATE_STRING_REP_LENGTH];
142
 
    size_t tmp_string_len;
143
 
 
144
 
    tmp_string_len= temporal.to_string(tmp_string, MAX_DATE_STRING_REP_LENGTH);
145
 
    assert(tmp_string_len < MAX_DATE_STRING_REP_LENGTH);
146
 
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp_string);
147
 
    return 1;
148
 
  }
149
 
 
150
 
  int64_t int_value;
151
 
  temporal.to_int64_t(&int_value);
152
 
 
153
 
#ifdef WORDS_BIGENDIAN
154
 
  if (getTable() && getTable()->s->db_low_byte_first)
155
 
  {
156
 
    int8store(ptr, int_value);
157
 
  }
158
 
  else
159
 
#endif
160
 
    int64_tstore(ptr, int_value);
161
 
  return 0;
162
 
}
 
36
                          uint len,
 
37
                          const CHARSET_INFO * const cs __attribute__((unused)))
 
38
{
 
39
  DRIZZLE_TIME time_tmp;
 
40
  int error;
 
41
  uint64_t tmp= 0;
 
42
  enum enum_drizzle_timestamp_type func_res;
 
43
  THD *thd= table ? table->in_use : current_thd;
 
44
 
 
45
  func_res= str_to_datetime(from, len, &time_tmp,
 
46
                            (TIME_FUZZY_DATE |
 
47
                             (thd->variables.sql_mode &
 
48
                              (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))),
 
49
                            &error);
 
50
  if ((int) func_res > (int) DRIZZLE_TIMESTAMP_ERROR)
 
51
    tmp= TIME_to_uint64_t_datetime(&time_tmp);
 
52
  else
 
53
    error= 1;                                 // Fix if invalid zero date
 
54
 
 
55
  if (error)
 
56
    set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
57
                         ER_WARN_DATA_OUT_OF_RANGE,
 
58
                         from, len, DRIZZLE_TIMESTAMP_DATETIME, 1);
 
59
 
 
60
#ifdef WORDS_BIGENDIAN
 
61
  if (table && table->s->db_low_byte_first)
 
62
  {
 
63
    int8store(ptr,tmp);
 
64
  }
 
65
  else
 
66
#endif
 
67
    int64_tstore(ptr,tmp);
 
68
  return error;
 
69
}
 
70
 
 
71
 
 
72
int Field_datetime::store(double nr)
 
73
{
 
74
  int error= 0;
 
75
  if (nr < 0.0 || nr > 99991231235959.0)
 
76
  {
 
77
    set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, 
 
78
                         ER_WARN_DATA_OUT_OF_RANGE,
 
79
                         nr, DRIZZLE_TIMESTAMP_DATETIME);
 
80
    nr= 0.0;
 
81
    error= 1;
 
82
  }
 
83
  error|= Field_datetime::store((int64_t) rint(nr), false);
 
84
  return error;
 
85
}
 
86
 
 
87
 
 
88
int Field_datetime::store(int64_t nr,
 
89
                          bool unsigned_val __attribute__((unused)))
 
90
{
 
91
  DRIZZLE_TIME not_used;
 
92
  int error;
 
93
  int64_t initial_nr= nr;
 
94
  THD *thd= table ? table->in_use : current_thd;
 
95
 
 
96
  nr= number_to_datetime(nr, &not_used, (TIME_FUZZY_DATE |
 
97
                                         (thd->variables.sql_mode &
 
98
                                          (MODE_NO_ZERO_DATE |
 
99
                                           MODE_INVALID_DATES))), &error);
 
100
 
 
101
  if (nr == -1LL)
 
102
  {
 
103
    nr= 0;
 
104
    error= 2;
 
105
  }
 
106
 
 
107
  if (error)
 
108
    set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
109
                         error == 2 ? ER_WARN_DATA_OUT_OF_RANGE :
 
110
                         ER_WARN_DATA_TRUNCATED, initial_nr,
 
111
                         DRIZZLE_TIMESTAMP_DATETIME, 1);
 
112
 
 
113
#ifdef WORDS_BIGENDIAN
 
114
  if (table && table->s->db_low_byte_first)
 
115
  {
 
116
    int8store(ptr,nr);
 
117
  }
 
118
  else
 
119
#endif
 
120
    int64_tstore(ptr,nr);
 
121
  return error;
 
122
}
 
123
 
 
124
 
 
125
int Field_datetime::store_time(DRIZZLE_TIME *ltime,timestamp_type time_type)
 
126
{
 
127
  int64_t tmp;
 
128
  int error= 0;
 
129
  /*
 
130
    We don't perform range checking here since values stored in TIME
 
131
    structure always fit into DATETIME range.
 
132
  */
 
133
  if (time_type == DRIZZLE_TIMESTAMP_DATE ||
 
134
      time_type == DRIZZLE_TIMESTAMP_DATETIME)
 
135
  {
 
136
    tmp=((ltime->year*10000L+ltime->month*100+ltime->day)*1000000LL+
 
137
         (ltime->hour*10000L+ltime->minute*100+ltime->second));
 
138
    if (check_date(ltime, tmp != 0,
 
139
                   (TIME_FUZZY_DATE |
 
140
                    (current_thd->variables.sql_mode &
 
141
                     (MODE_NO_ZERO_DATE | MODE_INVALID_DATES))), &error))
 
142
    {
 
143
      char buff[MAX_DATE_STRING_REP_LENGTH];
 
144
      String str(buff, sizeof(buff), &my_charset_utf8_general_ci);
 
145
      make_datetime((DATE_TIME_FORMAT *) 0, ltime, &str);
 
146
      set_datetime_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED,
 
147
                           str.ptr(), str.length(), DRIZZLE_TIMESTAMP_DATETIME,1);
 
148
    }
 
149
  }
 
150
  else
 
151
  {
 
152
    tmp=0;
 
153
    error= 1;
 
154
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
155
  }
 
156
#ifdef WORDS_BIGENDIAN
 
157
  if (table && table->s->db_low_byte_first)
 
158
  {
 
159
    int8store(ptr,tmp);
 
160
  }
 
161
  else
 
162
#endif
 
163
    int64_tstore(ptr,tmp);
 
164
  return error;
 
165
}
 
166
 
 
167
bool Field_datetime::send_binary(Protocol *protocol)
 
168
{
 
169
  DRIZZLE_TIME tm;
 
170
  Field_datetime::get_date(&tm, TIME_FUZZY_DATE);
 
171
  return protocol->store(&tm);
 
172
}
 
173
 
163
174
 
164
175
double Field_datetime::val_real(void)
165
176
{
169
180
int64_t Field_datetime::val_int(void)
170
181
{
171
182
  int64_t j;
172
 
 
173
 
  ASSERT_COLUMN_MARKED_FOR_READ;
174
 
 
175
183
#ifdef WORDS_BIGENDIAN
176
 
  if (getTable() && getTable()->s->db_low_byte_first)
 
184
  if (table && table->s->db_low_byte_first)
177
185
    j=sint8korr(ptr);
178
186
  else
179
187
#endif
183
191
 
184
192
 
185
193
String *Field_datetime::val_str(String *val_buffer,
186
 
                                String *)
 
194
                                String *val_ptr __attribute__((unused)))
187
195
{
188
 
  val_buffer->alloc(DateTime::MAX_STRING_LENGTH);
189
 
  val_buffer->length(DateTime::MAX_STRING_LENGTH);
190
 
  int64_t tmp;
191
 
 
192
 
  ASSERT_COLUMN_MARKED_FOR_READ;
 
196
  val_buffer->alloc(field_length);
 
197
  val_buffer->length(field_length);
 
198
  uint64_t tmp;
 
199
  long part1,part2;
 
200
  char *pos;
 
201
  int part3;
193
202
 
194
203
#ifdef WORDS_BIGENDIAN
195
 
  if (getTable() && getTable()->s->db_low_byte_first)
 
204
  if (table && table->s->db_low_byte_first)
196
205
    tmp=sint8korr(ptr);
197
206
  else
198
207
#endif
199
208
    int64_tget(tmp,ptr);
200
209
 
201
 
  DateTime dt;
202
 
 
203
 
  /* TODO: add an assert that this succeeds
204
 
   * currently fails due to bug in allowing
205
 
   * ALTER TABLE to add a datetime column that's
206
 
   * not null without a default value.
207
 
   */
208
 
  dt.from_int64_t(tmp, false); /* NOTE: this does *NOT* attempt convertion
209
 
                                 from formats such as 20090101 as
210
 
                                 the stored value has already been
211
 
                                 converted.
212
 
                               */
213
 
 
214
 
  int rlen;
215
 
  rlen= dt.to_string((char*)val_buffer->ptr(), DateTime::MAX_STRING_LENGTH);
216
 
  assert((rlen+1) <  DateTime::MAX_STRING_LENGTH);
217
 
 
218
 
  val_buffer->length(rlen);
219
 
 
 
210
  /*
 
211
    Avoid problem with slow int64_t arithmetic and sprintf
 
212
  */
 
213
 
 
214
  part1=(long) (tmp/1000000LL);
 
215
  part2=(long) (tmp - (uint64_t) part1*1000000LL);
 
216
 
 
217
  pos=(char*) val_buffer->ptr() + MAX_DATETIME_WIDTH;
 
218
  *pos--=0;
 
219
  *pos--= (char) ('0'+(char) (part2%10)); part2/=10;
 
220
  *pos--= (char) ('0'+(char) (part2%10)); part3= (int) (part2 / 10);
 
221
  *pos--= ':';
 
222
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
223
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
224
  *pos--= ':';
 
225
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
226
  *pos--= (char) ('0'+(char) part3);
 
227
  *pos--= ' ';
 
228
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
 
229
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
 
230
  *pos--= '-';
 
231
  *pos--= (char) ('0'+(char) (part1%10)); part1/=10;
 
232
  *pos--= (char) ('0'+(char) (part1%10)); part3= (int) (part1/10);
 
233
  *pos--= '-';
 
234
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
235
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
236
  *pos--= (char) ('0'+(char) (part3%10)); part3/=10;
 
237
  *pos=(char) ('0'+(char) part3);
220
238
  return val_buffer;
221
239
}
222
240
 
223
 
bool Field_datetime::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzydate)
 
241
bool Field_datetime::get_date(DRIZZLE_TIME *ltime, uint fuzzydate)
224
242
{
225
243
  int64_t tmp=Field_datetime::val_int();
226
244
  uint32_t part1,part2;
227
 
  part1=(uint32_t) (tmp/INT64_C(1000000));
228
 
  part2=(uint32_t) (tmp - (uint64_t) part1*INT64_C(1000000));
 
245
  part1=(uint32_t) (tmp/1000000LL);
 
246
  part2=(uint32_t) (tmp - (uint64_t) part1*1000000LL);
229
247
 
230
248
  ltime->time_type=     DRIZZLE_TIMESTAMP_DATETIME;
231
249
  ltime->neg=           0;
244
262
  return Field_datetime::get_date(ltime,0);
245
263
}
246
264
 
247
 
int Field_datetime::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
265
int Field_datetime::cmp(const uchar *a_ptr, const uchar *b_ptr)
248
266
{
249
267
  int64_t a,b;
250
268
#ifdef WORDS_BIGENDIAN
251
 
  if (getTable() && getTable()->s->db_low_byte_first)
 
269
  if (table && table->s->db_low_byte_first)
252
270
  {
253
271
    a=sint8korr(a_ptr);
254
272
    b=sint8korr(b_ptr);
263
281
    ((uint64_t) a > (uint64_t) b) ? 1 : 0;
264
282
}
265
283
 
266
 
void Field_datetime::sort_string(unsigned char *to,uint32_t )
 
284
void Field_datetime::sort_string(uchar *to,uint length __attribute__((unused)))
267
285
{
268
286
#ifdef WORDS_BIGENDIAN
269
 
  if (!getTable() || !getTable()->s->db_low_byte_first)
 
287
  if (!table || !table->s->db_low_byte_first)
270
288
  {
271
289
    to[0] = ptr[0];
272
290
    to[1] = ptr[1];
297
315
  res.set_ascii(STRING_WITH_LEN("datetime"));
298
316
}
299
317
 
300
 
} /* namespace drizzled */