← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/datetime.cc

Merge Stewart's dead code removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/datetime.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>
 
21
#include "drizzled/server_includes.h"
23
22
#include "drizzled/field/datetime.h"
24
23
#include "drizzled/error.h"
25
24
#include "drizzled/table.h"
26
25
#include "drizzled/temporal.h"
27
26
#include "drizzled/session.h"
28
27
 
29
 
#include <math.h>
30
 
 
31
28
#include <sstream>
32
29
#include <string>
33
30
 
34
31
 
35
 
namespace drizzled
36
 
{
37
 
 
38
32
/****************************************************************************
39
33
** datetime type
40
34
** In string context: YYYY-MM-DD HH:MM:DD
41
35
** In number context: YYYYMMDDHHMMDD
 
36
** Stored as a 8 byte unsigned int. Should sometimes be change to a 6 byte int.
42
37
****************************************************************************/
43
38
 
44
39
int Field_datetime::store(const char *from,
50
45
   * Try to create a DateTime from the supplied string.  Throw an error
51
46
   * if unable to create a valid DateTime.  
52
47
   */
53
 
  DateTime temporal;
 
48
  drizzled::DateTime temporal;
54
49
  if (! temporal.from_string(from, (size_t) len))
55
50
  {
56
51
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), from);
61
56
  temporal.to_int64_t(&int_value);
62
57
 
63
58
#ifdef WORDS_BIGENDIAN
64
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
59
  if (table && table->s->db_low_byte_first)
65
60
  {
66
61
    int8store(ptr, int_value);
67
62
  }
76
71
  ASSERT_COLUMN_MARKED_FOR_WRITE;
77
72
  if (from < 0.0 || from > 99991231235959.0)
78
73
  {
79
 
    /* Convert the double to a string using boost::lexical_cast */
80
 
    std::string tmp(boost::lexical_cast<std::string>(from));
 
74
    /* Convert the double to a string using stringstream */
 
75
    std::stringstream ss;
 
76
    std::string tmp;
 
77
    ss.precision(18); /* 18 places should be fine for error display of double input. */
 
78
    ss << from; ss >> tmp;
81
79
 
82
80
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp.c_str());
83
81
    return 2;
92
90
   * Try to create a DateTime from the supplied integer.  Throw an error
93
91
   * if unable to create a valid DateTime.  
94
92
   */
95
 
  DateTime temporal;
 
93
  drizzled::DateTime temporal;
96
94
  if (! temporal.from_int64_t(from))
97
95
  {
98
 
    /* Convert the integer to a string using boost::lexical_cast */
99
 
    std::string tmp(boost::lexical_cast<std::string>(from));
 
96
    /* Convert the integer to a string using stringstream */
 
97
    std::stringstream ss;
 
98
    std::string tmp;
 
99
    ss << from; ss >> tmp;
100
100
 
101
101
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp.c_str());
102
102
    return 2;
111
111
  temporal.to_int64_t(&int_value);
112
112
 
113
113
#ifdef WORDS_BIGENDIAN
114
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
114
  if (table && table->s->db_low_byte_first)
115
115
  {
116
116
    int8store(ptr, int_value);
117
117
  }
121
121
  return 0;
122
122
}
123
123
 
124
 
int Field_datetime::store_time(type::Time &ltime, type::timestamp_t)
 
124
int Field_datetime::store_time(DRIZZLE_TIME *ltime, enum enum_drizzle_timestamp_type)
125
125
{
126
 
  DateTime temporal;
 
126
  drizzled::DateTime temporal;
127
127
 
128
 
  temporal.set_years(ltime.year);
129
 
  temporal.set_months(ltime.month);
130
 
  temporal.set_days(ltime.day);
131
 
  temporal.set_hours(ltime.hour);
132
 
  temporal.set_minutes(ltime.minute);
133
 
  temporal.set_seconds(ltime.second);
 
128
  temporal.set_years(ltime->year);
 
129
  temporal.set_months(ltime->month);
 
130
  temporal.set_days(ltime->day);
 
131
  temporal.set_hours(ltime->hour);
 
132
  temporal.set_minutes(ltime->minute);
 
133
  temporal.set_seconds(ltime->second);
134
134
 
135
135
  if (! temporal.is_valid())
136
136
  {
137
 
    char tmp_string[type::Time::MAX_STRING_LENGTH];
 
137
    char tmp_string[MAX_DATE_STRING_REP_LENGTH];
138
138
    size_t tmp_string_len;
139
139
 
140
 
    tmp_string_len= temporal.to_string(tmp_string, type::Time::MAX_STRING_LENGTH);
141
 
    assert(tmp_string_len < type::Time::MAX_STRING_LENGTH);
 
140
    tmp_string_len= temporal.to_string(tmp_string, MAX_DATE_STRING_REP_LENGTH);
 
141
    assert(tmp_string_len < MAX_DATE_STRING_REP_LENGTH);
142
142
    my_error(ER_INVALID_DATETIME_VALUE, MYF(ME_FATALERROR), tmp_string);
143
143
    return 1;
144
144
  }
147
147
  temporal.to_int64_t(&int_value);
148
148
 
149
149
#ifdef WORDS_BIGENDIAN
150
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
150
  if (table && table->s->db_low_byte_first)
151
151
  {
152
152
    int8store(ptr, int_value);
153
153
  }
154
154
  else
155
155
#endif
156
156
    int64_tstore(ptr, int_value);
157
 
 
158
157
  return 0;
159
158
}
160
159
 
170
169
  ASSERT_COLUMN_MARKED_FOR_READ;
171
170
 
172
171
#ifdef WORDS_BIGENDIAN
173
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
172
  if (table && table->s->db_low_byte_first)
174
173
    j=sint8korr(ptr);
175
174
  else
176
175
#endif
182
181
String *Field_datetime::val_str(String *val_buffer,
183
182
                                String *)
184
183
{
185
 
  val_buffer->alloc(DateTime::MAX_STRING_LENGTH);
186
 
  val_buffer->length(DateTime::MAX_STRING_LENGTH);
 
184
  val_buffer->alloc(drizzled::DateTime::MAX_STRING_LENGTH);
 
185
  val_buffer->length(drizzled::DateTime::MAX_STRING_LENGTH);
187
186
  int64_t tmp;
188
187
 
189
188
  ASSERT_COLUMN_MARKED_FOR_READ;
190
189
 
191
190
#ifdef WORDS_BIGENDIAN
192
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
191
  if (table && table->s->db_low_byte_first)
193
192
    tmp=sint8korr(ptr);
194
193
  else
195
194
#endif
196
195
    int64_tget(tmp,ptr);
197
196
 
198
 
  DateTime dt;
 
197
  drizzled::DateTime dt;
199
198
 
200
199
  /* TODO: add an assert that this succeeds
201
200
   * currently fails due to bug in allowing
203
202
   * not null without a default value.
204
203
   */
205
204
  dt.from_int64_t(tmp, false); /* NOTE: this does *NOT* attempt convertion
206
 
                                 from formats such as 20090101 as
207
 
                                 the stored value has already been
208
 
                                 converted.
209
 
                               */
 
205
                                        from formats such as 20090101 as
 
206
                                        the stored value has already been
 
207
                                        converted.
 
208
                               */
210
209
 
211
210
  int rlen;
212
 
  rlen= dt.to_string((char*)val_buffer->ptr(), DateTime::MAX_STRING_LENGTH);
213
 
  assert((rlen+1) <  DateTime::MAX_STRING_LENGTH);
 
211
  rlen= dt.to_string((char*)val_buffer->ptr(), drizzled::DateTime::MAX_STRING_LENGTH);
 
212
  assert((rlen+1) <  drizzled::DateTime::MAX_STRING_LENGTH);
214
213
 
215
214
  val_buffer->length(rlen);
216
215
 
217
216
  return val_buffer;
218
217
}
219
218
 
220
 
bool Field_datetime::get_date(type::Time &ltime, uint32_t fuzzydate)
 
219
bool Field_datetime::get_date(DRIZZLE_TIME *ltime, uint32_t fuzzydate)
221
220
{
222
221
  int64_t tmp=Field_datetime::val_int();
223
222
  uint32_t part1,part2;
224
223
  part1=(uint32_t) (tmp/INT64_C(1000000));
225
224
  part2=(uint32_t) (tmp - (uint64_t) part1*INT64_C(1000000));
226
225
 
227
 
  ltime.time_type=      type::DRIZZLE_TIMESTAMP_DATETIME;
228
 
  ltime.neg=            0;
229
 
  ltime.second_part=    0;
230
 
  ltime.second= (int) (part2%100);
231
 
  ltime.minute= (int) (part2/100%100);
232
 
  ltime.hour=           (int) (part2/10000);
233
 
  ltime.day=            (int) (part1%100);
234
 
  ltime.month=  (int) (part1/100%100);
235
 
  ltime.year=           (int) (part1/10000);
236
 
 
237
 
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime.month || !ltime.day)) ? 1 : 0;
 
226
  ltime->time_type=     DRIZZLE_TIMESTAMP_DATETIME;
 
227
  ltime->neg=           0;
 
228
  ltime->second_part=   0;
 
229
  ltime->second=        (int) (part2%100);
 
230
  ltime->minute=        (int) (part2/100%100);
 
231
  ltime->hour=          (int) (part2/10000);
 
232
  ltime->day=           (int) (part1%100);
 
233
  ltime->month=         (int) (part1/100%100);
 
234
  ltime->year=          (int) (part1/10000);
 
235
  return (!(fuzzydate & TIME_FUZZY_DATE) && (!ltime->month || !ltime->day)) ? 1 : 0;
238
236
}
239
237
 
240
 
bool Field_datetime::get_time(type::Time &ltime)
 
238
bool Field_datetime::get_time(DRIZZLE_TIME *ltime)
241
239
{
242
240
  return Field_datetime::get_date(ltime,0);
243
241
}
246
244
{
247
245
  int64_t a,b;
248
246
#ifdef WORDS_BIGENDIAN
249
 
  if (getTable() && getTable()->isDatabaseLowByteFirst())
 
247
  if (table && table->s->db_low_byte_first)
250
248
  {
251
249
    a=sint8korr(a_ptr);
252
250
    b=sint8korr(b_ptr);
264
262
void Field_datetime::sort_string(unsigned char *to,uint32_t )
265
263
{
266
264
#ifdef WORDS_BIGENDIAN
267
 
  if (not getTable() || not getTable()->isDatabaseLowByteFirst())
 
265
  if (!table || !table->s->db_low_byte_first)
268
266
  {
269
267
    to[0] = ptr[0];
270
268
    to[1] = ptr[1];
295
293
  res.set_ascii(STRING_WITH_LEN("datetime"));
296
294
}
297
295
 
298
 
} /* namespace drizzled */