← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/epoch.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/epoch.cc
1
1
/* -*- mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems
 
4
 *  Copyright (C) 2008 Sun Microsystems, Inc.
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
#include "config.h"
 
21
#include <config.h>
 
22
 
22
23
#include <boost/lexical_cast.hpp>
23
 
#include <drizzled/field/timestamp.h>
 
24
#include <drizzled/field/epoch.h>
24
25
#include <drizzled/error.h>
25
26
#include <drizzled/tztime.h>
26
27
#include <drizzled/table.h>
27
28
#include <drizzled/session.h>
 
29
#include <drizzled/current_session.h>
28
30
 
29
31
#include <math.h>
30
32
 
31
33
#include <sstream>
32
34
 
33
 
#include "drizzled/temporal.h"
 
35
#include <drizzled/temporal.h>
34
36
 
35
37
namespace drizzled
36
38
{
37
39
 
 
40
namespace field
 
41
{
 
42
 
38
43
/**
39
44
  TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to
40
45
  2038-01-01 00:00:00 UTC stored as number of seconds since Unix
78
83
  course is non-standard.) In most cases user won't notice any change, only
79
84
  exception is different behavior of old/new timestamps during ALTER TABLE.
80
85
 */
81
 
Field_timestamp::Field_timestamp(unsigned char *ptr_arg,
82
 
                                 uint32_t,
83
 
                                 unsigned char *null_ptr_arg,
84
 
                                 unsigned char null_bit_arg,
85
 
                                 enum utype unireg_check_arg,
86
 
                                 const char *field_name_arg,
87
 
                                 TableShare *share,
88
 
                                 const CHARSET_INFO * const cs)
89
 
  :Field_str(ptr_arg,
90
 
             DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
91
 
             null_ptr_arg,
92
 
             null_bit_arg,
93
 
             field_name_arg,
94
 
             cs)
 
86
  Epoch::Epoch(unsigned char *ptr_arg,
 
87
               unsigned char *null_ptr_arg,
 
88
               unsigned char null_bit_arg,
 
89
               enum utype unireg_check_arg,
 
90
               const char *field_name_arg,
 
91
               drizzled::TableShare *share) :
 
92
  Field_str(ptr_arg,
 
93
            MicroTimestamp::MAX_STRING_LENGTH - 1, /* no \0 */
 
94
            null_ptr_arg,
 
95
            null_bit_arg,
 
96
            field_name_arg,
 
97
            &my_charset_bin)
95
98
{
96
 
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
97
 
  flags|= UNSIGNED_FLAG;
98
99
  unireg_check= unireg_check_arg;
99
100
  if (! share->getTimestampField() && unireg_check != NONE)
100
101
  {
101
102
    /* This timestamp has auto-update */
102
103
    share->setTimestampField(this);
103
 
    flags|= TIMESTAMP_FLAG;
 
104
    flags|= FUNCTION_DEFAULT_FLAG;
104
105
    if (unireg_check != TIMESTAMP_DN_FIELD)
105
106
      flags|= ON_UPDATE_NOW_FLAG;
106
107
  }
107
108
}
108
109
 
109
 
Field_timestamp::Field_timestamp(bool maybe_null_arg,
110
 
                                 const char *field_name_arg,
111
 
                                 const CHARSET_INFO * const cs)
112
 
  :Field_str((unsigned char*) NULL,
113
 
             DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
114
 
             maybe_null_arg ? (unsigned char*) "": 0,
115
 
             0,
116
 
             field_name_arg,
117
 
             cs)
 
110
Epoch::Epoch(bool maybe_null_arg,
 
111
             const char *field_name_arg) :
 
112
  Field_str((unsigned char*) NULL,
 
113
            MicroTimestamp::MAX_STRING_LENGTH - 1, /* no \0 */
 
114
            maybe_null_arg ? (unsigned char*) "": 0,
 
115
            0,
 
116
            field_name_arg,
 
117
            &my_charset_bin)
118
118
{
119
 
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
120
 
  flags|= UNSIGNED_FLAG;
121
119
  if (unireg_check != TIMESTAMP_DN_FIELD)
122
120
    flags|= ON_UPDATE_NOW_FLAG;
123
121
}
128
126
  Returns value indicating during which operations this TIMESTAMP field
129
127
  should be auto-set to current timestamp.
130
128
*/
131
 
timestamp_auto_set_type Field_timestamp::get_auto_set_type() const
 
129
timestamp_auto_set_type Epoch::get_auto_set_type() const
132
130
{
133
131
  switch (unireg_check)
134
132
  {
156
154
  }
157
155
}
158
156
 
159
 
int Field_timestamp::store(const char *from,
160
 
                           uint32_t len,
161
 
                           const CHARSET_INFO * const )
 
157
int Epoch::store(const char *from,
 
158
                 uint32_t len,
 
159
                 const CHARSET_INFO * const )
162
160
{
163
161
  Timestamp temporal;
164
162
 
165
163
  ASSERT_COLUMN_MARKED_FOR_WRITE;
166
164
 
167
 
  if (! temporal.from_string(from, (size_t) len))
 
165
  if (not temporal.from_string(from, (size_t) len))
168
166
  {
169
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
 
167
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
170
168
    return 1;
171
169
  }
172
170
 
173
171
  time_t tmp;
174
 
  temporal.to_time_t(&tmp);
 
172
  temporal.to_time_t(tmp);
175
173
 
176
 
  store_timestamp(tmp);
 
174
  uint64_t time_tmp= tmp;
 
175
  pack_num(time_tmp);
177
176
  return 0;
178
177
}
179
178
 
180
 
int Field_timestamp::store(double from)
 
179
int Epoch::store(double from)
181
180
{
182
181
  ASSERT_COLUMN_MARKED_FOR_WRITE;
183
182
 
184
 
  if (from < 0 || from > 99991231235959.0)
 
183
  uint64_t from_tmp= (uint64_t)from;
 
184
 
 
185
  Timestamp temporal;
 
186
  if (not temporal.from_int64_t(from_tmp))
185
187
  {
186
 
    /* Convert the double to a string using stringstream */
187
 
    std::stringstream ss;
188
 
    std::string tmp;
189
 
    ss.precision(18); /* 18 places should be fine for error display of double input. */
190
 
    ss << from; 
191
 
    ss >> tmp;
 
188
    /* Convert the integer to a string using boost::lexical_cast */
 
189
    std::string tmp(boost::lexical_cast<std::string>(from));
192
190
 
193
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
 
191
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
194
192
    return 2;
195
193
  }
196
 
  return Field_timestamp::store((int64_t) rint(from), false);
197
 
}
198
 
 
199
 
int Field_timestamp::store(int64_t from, bool)
 
194
 
 
195
  time_t tmp;
 
196
  temporal.to_time_t(tmp);
 
197
 
 
198
  uint64_t tmp_micro= tmp;
 
199
  pack_num(tmp_micro);
 
200
 
 
201
  return 0;
 
202
}
 
203
 
 
204
int Epoch::store_decimal(const type::Decimal *value)
 
205
{
 
206
  double tmp;
 
207
  value->convert(tmp);
 
208
 
 
209
  return store(tmp);
 
210
}
 
211
 
 
212
int Epoch::store(int64_t from, bool)
200
213
{
201
214
  ASSERT_COLUMN_MARKED_FOR_WRITE;
202
215
 
205
218
   * if unable to create a valid DateTime.  
206
219
   */
207
220
  Timestamp temporal;
208
 
  if (! temporal.from_int64_t(from))
 
221
  if (not temporal.from_int64_t(from))
209
222
  {
210
223
    /* Convert the integer to a string using boost::lexical_cast */
211
224
    std::string tmp(boost::lexical_cast<std::string>(from));
212
225
 
213
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
 
226
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
214
227
    return 2;
215
228
  }
216
229
 
217
230
  time_t tmp;
218
 
  temporal.to_time_t(&tmp);
219
 
 
220
 
  store_timestamp(tmp);
 
231
  temporal.to_time_t(tmp);
 
232
 
 
233
  uint64_t tmp64= tmp;
 
234
  pack_num(tmp64);
 
235
 
221
236
  return 0;
222
237
}
223
238
 
224
 
double Field_timestamp::val_real(void)
 
239
double Epoch::val_real(void) const
225
240
{
226
 
  return (double) Field_timestamp::val_int();
 
241
  return (double) Epoch::val_int();
227
242
}
228
243
 
229
 
int64_t Field_timestamp::val_int(void)
 
244
int64_t Epoch::val_int(void) const
230
245
{
231
246
  uint64_t temp;
232
247
 
233
248
  ASSERT_COLUMN_MARKED_FOR_READ;
234
249
 
235
 
#ifdef WORDS_BIGENDIAN
236
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
237
 
    temp= uint8korr(ptr);
238
 
  else
239
 
#endif
240
 
    int64_tget(temp, ptr);
 
250
  unpack_num(temp);
241
251
 
242
252
  Timestamp temporal;
243
253
  (void) temporal.from_time_t((time_t) temp);
248
258
  return result;
249
259
}
250
260
 
251
 
String *Field_timestamp::val_str(String *val_buffer, String *)
 
261
String *Epoch::val_str(String *val_buffer, String *) const
252
262
{
253
 
  uint64_t temp;
 
263
  uint64_t temp= 0;
254
264
  char *to;
255
265
  int to_len= field_length + 1;
256
266
 
257
267
  val_buffer->alloc(to_len);
258
268
  to= (char *) val_buffer->ptr();
259
269
 
260
 
#ifdef WORDS_BIGENDIAN
261
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
262
 
    temp= uint8korr(ptr);
263
 
  else
264
 
#endif
265
 
    int64_tget(temp, ptr);
 
270
  unpack_num(temp);
266
271
 
267
272
  val_buffer->set_charset(&my_charset_bin);     /* Safety */
268
273
 
277
282
  return val_buffer;
278
283
}
279
284
 
280
 
bool Field_timestamp::get_date(DRIZZLE_TIME *ltime, uint32_t)
 
285
bool Epoch::get_date(type::Time &ltime, uint32_t) const
281
286
{
282
287
  uint64_t temp;
 
288
  type::Time::epoch_t time_temp;
283
289
 
284
 
#ifdef WORDS_BIGENDIAN
285
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
286
 
    temp= uint8korr(ptr);
287
 
  else
288
 
#endif
289
 
    int64_tget(temp, ptr);
 
290
  unpack_num(temp);
 
291
  time_temp= temp;
290
292
  
291
 
  memset(ltime, 0, sizeof(*ltime));
292
 
 
293
 
  Timestamp temporal;
294
 
  (void) temporal.from_time_t((time_t) temp);
295
 
 
296
 
  /* @TODO Goodbye the below code when DRIZZLE_TIME is finally gone.. */
297
 
 
298
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
299
 
  ltime->year= temporal.years();
300
 
  ltime->month= temporal.months();
301
 
  ltime->day= temporal.days();
302
 
  ltime->hour= temporal.hours();
303
 
  ltime->minute= temporal.minutes();
304
 
  ltime->second= temporal.seconds();
 
293
  ltime.reset();
 
294
 
 
295
  ltime.store(time_temp);
305
296
 
306
297
  return 0;
307
298
}
308
299
 
309
 
bool Field_timestamp::get_time(DRIZZLE_TIME *ltime)
310
 
{
311
 
  return Field_timestamp::get_date(ltime,0);
312
 
}
313
 
 
314
 
int Field_timestamp::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
315
 
{
316
 
  int64_t a,b;
317
 
#ifdef WORDS_BIGENDIAN
318
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
319
 
  {
320
 
    a=sint8korr(a_ptr);
321
 
    b=sint8korr(b_ptr);
322
 
  }
323
 
  else
324
 
#endif
325
 
  {
326
 
    int64_tget(a, a_ptr);
327
 
    int64_tget(b, b_ptr);
328
 
  }
329
 
  return ((uint64_t) a < (uint64_t) b) ? -1 : ((uint64_t) a > (uint64_t) b) ? 1 : 0;
330
 
}
331
 
 
332
 
 
333
 
void Field_timestamp::sort_string(unsigned char *to,uint32_t )
 
300
bool Epoch::get_time(type::Time &ltime) const
 
301
{
 
302
  return Epoch::get_date(ltime, 0);
 
303
}
 
304
 
 
305
int Epoch::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
306
{
 
307
  uint64_t a,b;
 
308
 
 
309
  unpack_num(a, a_ptr);
 
310
  unpack_num(b, b_ptr);
 
311
 
 
312
  return (a < b) ? -1 : (a > b) ? 1 : 0;
 
313
}
 
314
 
 
315
 
 
316
void Epoch::sort_string(unsigned char *to,uint32_t )
334
317
{
335
318
#ifdef WORDS_BIGENDIAN
336
319
  if (!getTable() || !getTable()->getShare()->db_low_byte_first)
358
341
  }
359
342
}
360
343
 
361
 
void Field_timestamp::sql_type(String &res) const
 
344
void Epoch::sql_type(String &res) const
362
345
{
363
346
  res.set_ascii(STRING_WITH_LEN("timestamp"));
364
347
}
365
348
 
366
 
void Field_timestamp::set_time()
 
349
void Epoch::set_time()
367
350
{
368
351
  Session *session= getTable() ? getTable()->in_use : current_session;
369
 
  time_t tmp= session->query_start();
 
352
  time_t tmp= session->getCurrentTimestampEpoch();
 
353
 
370
354
  set_notnull();
371
 
  store_timestamp(tmp);
 
355
  pack_num(static_cast<uint32_t>(tmp));
372
356
}
373
357
 
374
 
void Field_timestamp::set_default()
 
358
void Epoch::set_default()
375
359
{
376
360
  if (getTable()->timestamp_field == this &&
377
361
      unireg_check != TIMESTAMP_UN_FIELD)
 
362
  {
378
363
    set_time();
 
364
  }
379
365
  else
 
366
  {
380
367
    Field::set_default();
 
368
  }
381
369
}
382
370
 
383
 
long Field_timestamp::get_timestamp(bool *null_value)
 
371
long Epoch::get_timestamp(bool *null_value) const
384
372
{
385
373
  if ((*null_value= is_null()))
386
374
    return 0;
387
 
#ifdef WORDS_BIGENDIAN
388
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
389
 
    return sint8korr(ptr);
390
 
#endif
391
 
  int64_t tmp;
392
 
  int64_tget(tmp, ptr);
393
 
  return tmp;
 
375
 
 
376
  uint64_t tmp;
 
377
  return unpack_num(tmp);
394
378
}
395
379
 
396
 
void Field_timestamp::store_timestamp(int64_t timestamp)
 
380
size_t Epoch::max_string_length()
397
381
{
398
 
#ifdef WORDS_BIGENDIAN
399
 
  if (getTable() && getTable()->getShare()->db_low_byte_first)
400
 
  {
401
 
    int8store(ptr, timestamp);
402
 
  }
403
 
  else
404
 
#endif
405
 
    int64_tstore(ptr, timestamp);
 
382
  return sizeof(uint64_t);
406
383
}
407
384
 
 
385
} /* namespace field */
408
386
} /* namespace drizzled */