← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/timestamp.cc

  • Committer: Brian Aker
  • Date: 2008-07-28 18:01:38 UTC
  • Revision ID: brian@tangent.org-20080728180138-q2pxlq0qiapvqsdn
Remove YEAR field type

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/timestamp.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
 
 *  Copyright (C) 2008 Sun Microsystems
 
4
 *  Copyright (C) 2008 MySQL
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
#ifdef USE_PRAGMA_IMPLEMENTATION
 
22
#pragma implementation                          // gcc: Class implementation
 
23
#endif
21
24
 
22
 
#include "config.h"
23
25
#include <drizzled/field/timestamp.h>
24
 
#include <drizzled/error.h>
25
 
#include <drizzled/tztime.h>
26
 
#include <drizzled/table.h>
27
 
#include <drizzled/session.h>
28
 
 
29
 
#include <math.h>
30
 
 
31
 
#include <sstream>
32
 
 
33
 
#include "drizzled/temporal.h"
34
26
 
35
27
/**
36
 
  TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to
37
 
  2038-01-01 00:00:00 UTC stored as number of seconds since Unix
 
28
  TIMESTAMP type holds datetime values in range from 1970-01-01 00:00:01 UTC to 
 
29
  2038-01-01 00:00:00 UTC stored as number of seconds since Unix 
38
30
  Epoch in UTC.
39
 
 
40
 
  Up to one of timestamps columns in the table can be automatically
 
31
  
 
32
  Up to one of timestamps columns in the table can be automatically 
41
33
  set on row update and/or have NOW() as default value.
42
 
  TABLE::timestamp_field points to Field object for such timestamp with
 
34
  TABLE::timestamp_field points to Field object for such timestamp with 
43
35
  auto-set-on-update. TABLE::time_stamp holds offset in record + 1 for this
44
36
  field, and is used by handler code which performs updates required.
45
 
 
 
37
  
46
38
  Actually SQL-99 says that we should allow niladic functions (like NOW())
47
 
  as defaults for any field. Current limitations (only NOW() and only
48
 
  for one TIMESTAMP field) are because of restricted binary .frm format
 
39
  as defaults for any field. Current limitations (only NOW() and only 
 
40
  for one TIMESTAMP field) are because of restricted binary .frm format 
49
41
  and should go away in the future.
50
 
 
 
42
  
51
43
  Also because of this limitation of binary .frm format we use 5 different
52
44
  unireg_check values with TIMESTAMP field to distinguish various cases of
53
45
  DEFAULT or ON UPDATE values. These values are:
54
 
 
 
46
  
55
47
  TIMESTAMP_OLD_FIELD - old timestamp, if there was not any fields with
56
 
    auto-set-on-update (or now() as default) in this table before, then this
57
 
    field has NOW() as default and is updated when row changes, else it is
 
48
    auto-set-on-update (or now() as default) in this table before, then this 
 
49
    field has NOW() as default and is updated when row changes, else it is 
58
50
    field which has 0 as default value and is not automatically updated.
59
51
  TIMESTAMP_DN_FIELD - field with NOW() as default but not set on update
60
52
    automatically (TIMESTAMP DEFAULT NOW())
61
 
  TIMESTAMP_UN_FIELD - field which is set on update automatically but has not
62
 
    NOW() as default (but it may has 0 or some other const timestamp as
 
53
  TIMESTAMP_UN_FIELD - field which is set on update automatically but has not 
 
54
    NOW() as default (but it may has 0 or some other const timestamp as 
63
55
    default) (TIMESTAMP ON UPDATE NOW()).
64
 
  TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on
 
56
  TIMESTAMP_DNUN_FIELD - field which has now() as default and is auto-set on 
65
57
    update. (TIMESTAMP DEFAULT NOW() ON UPDATE NOW())
66
 
  NONE - field which is not auto-set on update with some other than NOW()
 
58
  NONE - field which is not auto-set on update with some other than NOW() 
67
59
    default value (TIMESTAMP DEFAULT 0).
68
60
 
69
 
  Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are
70
 
  left only for preserving ability to read old tables. Such fields replaced
71
 
  with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is
72
 
  because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for
73
 
  "TIMESTAMP DEFAULT 'Const'" field. (Old timestamps allowed such
74
 
  specification too but ignored default value for first timestamp, which of
 
61
  Note that TIMESTAMP_OLD_FIELDs are never created explicitly now, they are 
 
62
  left only for preserving ability to read old tables. Such fields replaced 
 
63
  with their newer analogs in CREATE TABLE and in SHOW CREATE TABLE. This is 
 
64
  because we want to prefer NONE unireg_check before TIMESTAMP_OLD_FIELD for 
 
65
  "TIMESTAMP DEFAULT 'Const'" field. (Old timestamps allowed such 
 
66
  specification too but ignored default value for first timestamp, which of 
75
67
  course is non-standard.) In most cases user won't notice any change, only
76
68
  exception is different behavior of old/new timestamps during ALTER TABLE.
77
69
 */
78
 
Field_timestamp::Field_timestamp(unsigned char *ptr_arg,
79
 
                                 uint32_t,
80
 
                                 unsigned char *null_ptr_arg,
81
 
                                 unsigned char null_bit_arg,
 
70
 
 
71
Field_timestamp::Field_timestamp(uchar *ptr_arg,
 
72
                                 uint32_t len_arg __attribute__((unused)),
 
73
                                 uchar *null_ptr_arg, uchar null_bit_arg,
82
74
                                 enum utype unireg_check_arg,
83
75
                                 const char *field_name_arg,
84
 
                                 TableShare *share,
85
 
                                 const CHARSET_INFO * const cs)
86
 
  :Field_str(ptr_arg,
87
 
             drizzled::DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
88
 
             null_ptr_arg,
89
 
             null_bit_arg,
90
 
             field_name_arg,
91
 
             cs)
 
76
                                 TABLE_SHARE *share,
 
77
                                 CHARSET_INFO *cs)
 
78
  :Field_str(ptr_arg, MAX_DATETIME_WIDTH, null_ptr_arg, null_bit_arg,
 
79
             unireg_check_arg, field_name_arg, cs)
92
80
{
93
81
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
94
82
  flags|= UNSIGNED_FLAG;
95
 
  unireg_check= unireg_check_arg;
96
 
  if (! share->timestamp_field && unireg_check != NONE)
 
83
  if (!share->timestamp_field && unireg_check != NONE)
97
84
  {
98
85
    /* This timestamp has auto-update */
99
86
    share->timestamp_field= this;
103
90
  }
104
91
}
105
92
 
 
93
 
106
94
Field_timestamp::Field_timestamp(bool maybe_null_arg,
107
95
                                 const char *field_name_arg,
108
 
                                 const CHARSET_INFO * const cs)
109
 
  :Field_str((unsigned char*) NULL,
110
 
             drizzled::DateTime::MAX_STRING_LENGTH - 1 /* no \0 */,
111
 
             maybe_null_arg ? (unsigned char*) "": 0,
112
 
             0,
113
 
             field_name_arg,
114
 
             cs)
 
96
                                 CHARSET_INFO *cs)
 
97
  :Field_str((uchar*) 0, MAX_DATETIME_WIDTH,
 
98
             maybe_null_arg ? (uchar*) "": 0, 0,
 
99
             NONE, field_name_arg, cs)
115
100
{
116
101
  /* For 4.0 MYD and 4.0 InnoDB compatibility */
117
102
  flags|= UNSIGNED_FLAG;
118
 
  if (unireg_check != TIMESTAMP_DN_FIELD)
119
 
    flags|= ON_UPDATE_NOW_FLAG;
 
103
    if (unireg_check != TIMESTAMP_DN_FIELD)
 
104
      flags|= ON_UPDATE_NOW_FLAG;
120
105
}
121
106
 
 
107
 
122
108
/**
123
109
  Get auto-set type for TIMESTAMP field.
124
110
 
153
139
  }
154
140
}
155
141
 
 
142
 
156
143
int Field_timestamp::store(const char *from,
157
 
                           uint32_t len,
158
 
                           const CHARSET_INFO * const )
159
 
{
160
 
  drizzled::Timestamp temporal;
161
 
 
162
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
163
 
 
164
 
  if (! temporal.from_string(from, (size_t) len))
165
 
  {
166
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
167
 
    return 1;
168
 
  }
169
 
 
170
 
  time_t tmp;
171
 
  temporal.to_time_t(&tmp);
172
 
 
173
 
  store_timestamp(tmp);
174
 
  return 0;
175
 
}
176
 
 
177
 
int Field_timestamp::store(double from)
178
 
{
179
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
180
 
 
181
 
  if (from < 0 || from > 99991231235959.0)
182
 
  {
183
 
    /* Convert the double to a string using stringstream */
184
 
    std::stringstream ss;
185
 
    std::string tmp;
186
 
    ss.precision(18); /* 18 places should be fine for error display of double input. */
187
 
    ss << from; ss >> tmp;
188
 
 
189
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
190
 
    return 2;
191
 
  }
192
 
  return Field_timestamp::store((int64_t) rint(from), false);
193
 
}
194
 
 
195
 
int Field_timestamp::store(int64_t from, bool)
196
 
{
197
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
198
 
 
199
 
  /* 
200
 
   * Try to create a DateTime from the supplied integer.  Throw an error
201
 
   * if unable to create a valid DateTime.  
202
 
   */
203
 
  drizzled::Timestamp temporal;
204
 
  if (! temporal.from_int64_t(from))
205
 
  {
206
 
    /* Convert the integer to a string using stringstream */
207
 
    std::stringstream ss;
208
 
    std::string tmp;
209
 
    ss << from; ss >> tmp;
210
 
 
211
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
212
 
    return 2;
213
 
  }
214
 
 
215
 
  time_t tmp;
216
 
  temporal.to_time_t(&tmp);
217
 
 
218
 
  store_timestamp(tmp);
219
 
  return 0;
 
144
                           uint len,
 
145
                           CHARSET_INFO *cs __attribute__((unused)))
 
146
{
 
147
  MYSQL_TIME l_time;
 
148
  my_time_t tmp= 0;
 
149
  int error;
 
150
  bool have_smth_to_conv;
 
151
  bool in_dst_time_gap;
 
152
  THD *thd= table ? table->in_use : current_thd;
 
153
 
 
154
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
 
155
  have_smth_to_conv= (str_to_datetime(from, len, &l_time, 1, &error) >
 
156
                      MYSQL_TIMESTAMP_ERROR);
 
157
 
 
158
  if (error || !have_smth_to_conv)
 
159
  {
 
160
    error= 1;
 
161
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN, WARN_DATA_TRUNCATED,
 
162
                         from, len, MYSQL_TIMESTAMP_DATETIME, 1);
 
163
  }
 
164
 
 
165
  /* Only convert a correct date (not a zero date) */
 
166
  if (have_smth_to_conv && l_time.month)
 
167
  {
 
168
    if (!(tmp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
 
169
    {
 
170
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
171
                           ER_WARN_DATA_OUT_OF_RANGE,
 
172
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
 
173
      error= 1;
 
174
    }
 
175
    else if (in_dst_time_gap)
 
176
    {
 
177
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
178
                           ER_WARN_INVALID_TIMESTAMP,
 
179
                           from, len, MYSQL_TIMESTAMP_DATETIME, !error);
 
180
      error= 1;
 
181
    }
 
182
  }
 
183
  store_timestamp(tmp);
 
184
  return error;
 
185
}
 
186
 
 
187
 
 
188
int Field_timestamp::store(double nr)
 
189
{
 
190
  int error= 0;
 
191
  if (nr < 0 || nr > 99991231235959.0)
 
192
  {
 
193
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
194
                         ER_WARN_DATA_OUT_OF_RANGE,
 
195
                         nr, MYSQL_TIMESTAMP_DATETIME);
 
196
    nr= 0;                                      // Avoid overflow on buff
 
197
    error= 1;
 
198
  }
 
199
  error|= Field_timestamp::store((int64_t) rint(nr), false);
 
200
  return error;
 
201
}
 
202
 
 
203
 
 
204
int Field_timestamp::store(int64_t nr,
 
205
                           bool unsigned_val __attribute__((unused)))
 
206
{
 
207
  MYSQL_TIME l_time;
 
208
  my_time_t timestamp= 0;
 
209
  int error;
 
210
  bool in_dst_time_gap;
 
211
  THD *thd= table ? table->in_use : current_thd;
 
212
 
 
213
  /* We don't want to store invalid or fuzzy datetime values in TIMESTAMP */
 
214
  int64_t tmp= number_to_datetime(nr, &l_time, (thd->variables.sql_mode &
 
215
                                                 MODE_NO_ZERO_DATE) |
 
216
                                   MODE_NO_ZERO_IN_DATE, &error);
 
217
  if (tmp == -1LL)
 
218
  {
 
219
    error= 2;
 
220
  }
 
221
 
 
222
  if (!error && tmp)
 
223
  {
 
224
    if (!(timestamp= TIME_to_timestamp(thd, &l_time, &in_dst_time_gap)))
 
225
    {
 
226
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
227
                           ER_WARN_DATA_OUT_OF_RANGE,
 
228
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
 
229
      error= 1;
 
230
    }
 
231
    if (in_dst_time_gap)
 
232
    {
 
233
      set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
234
                           ER_WARN_INVALID_TIMESTAMP,
 
235
                           nr, MYSQL_TIMESTAMP_DATETIME, 1);
 
236
      error= 1;
 
237
    }
 
238
  } else if (error)
 
239
    set_datetime_warning(MYSQL_ERROR::WARN_LEVEL_WARN,
 
240
                         WARN_DATA_TRUNCATED,
 
241
                         nr, MYSQL_TIMESTAMP_DATETIME, 1);
 
242
 
 
243
  store_timestamp(timestamp);
 
244
  return error;
220
245
}
221
246
 
222
247
double Field_timestamp::val_real(void)
227
252
int64_t Field_timestamp::val_int(void)
228
253
{
229
254
  uint32_t temp;
230
 
 
231
 
  ASSERT_COLUMN_MARKED_FOR_READ;
232
 
 
 
255
  MYSQL_TIME time_tmp;
 
256
  THD  *thd= table ? table->in_use : current_thd;
 
257
 
 
258
  thd->time_zone_used= 1;
233
259
#ifdef WORDS_BIGENDIAN
234
260
  if (table && table->s->db_low_byte_first)
235
 
    temp= uint4korr(ptr);
 
261
    temp=uint4korr(ptr);
236
262
  else
237
263
#endif
238
 
    longget(temp, ptr);
239
 
 
240
 
  drizzled::Timestamp temporal;
241
 
  (void) temporal.from_time_t((time_t) temp);
242
 
 
243
 
  /* We must convert into a "timestamp-formatted integer" ... */
244
 
  int64_t result;
245
 
  temporal.to_int64_t(&result);
246
 
  return result;
 
264
    longget(temp,ptr);
 
265
 
 
266
  if (temp == 0L)                               // No time
 
267
    return(0);                                  /* purecov: inspected */
 
268
  
 
269
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp, (my_time_t)temp);
 
270
  
 
271
  return time_tmp.year * 10000000000LL + time_tmp.month * 100000000LL +
 
272
         time_tmp.day * 1000000L + time_tmp.hour * 10000L +
 
273
         time_tmp.minute * 100 + time_tmp.second;
247
274
}
248
275
 
249
 
String *Field_timestamp::val_str(String *val_buffer, String *)
 
276
 
 
277
String *Field_timestamp::val_str(String *val_buffer, String *val_ptr)
250
278
{
251
 
  uint32_t temp;
 
279
  uint32_t temp, temp2;
 
280
  MYSQL_TIME time_tmp;
 
281
  THD *thd= table ? table->in_use : current_thd;
252
282
  char *to;
253
 
  int to_len= field_length + 1;
254
 
 
255
 
  val_buffer->alloc(to_len);
256
 
  to= (char *) val_buffer->ptr();
257
 
 
 
283
 
 
284
  val_buffer->alloc(field_length+1);
 
285
  to= (char*) val_buffer->ptr();
 
286
  val_buffer->length(field_length);
 
287
 
 
288
  thd->time_zone_used= 1;
258
289
#ifdef WORDS_BIGENDIAN
259
290
  if (table && table->s->db_low_byte_first)
260
 
    temp= uint4korr(ptr);
 
291
    temp=uint4korr(ptr);
261
292
  else
262
293
#endif
263
 
    longget(temp, ptr);
264
 
 
265
 
  val_buffer->set_charset(&my_charset_bin);     /* Safety */
266
 
 
267
 
  drizzled::Timestamp temporal;
268
 
  (void) temporal.from_time_t((time_t) temp);
269
 
 
270
 
  int rlen;
271
 
  rlen= temporal.to_string(to, to_len);
272
 
  assert(rlen < to_len);
273
 
 
274
 
  val_buffer->length(rlen);
 
294
    longget(temp,ptr);
 
295
 
 
296
  if (temp == 0L)
 
297
  {                                   /* Zero time is "000000" */
 
298
    val_ptr->set(STRING_WITH_LEN("0000-00-00 00:00:00"), &my_charset_bin);
 
299
    return val_ptr;
 
300
  }
 
301
  val_buffer->set_charset(&my_charset_bin);     // Safety
 
302
  
 
303
  thd->variables.time_zone->gmt_sec_to_TIME(&time_tmp,(my_time_t)temp);
 
304
 
 
305
  temp= time_tmp.year % 100;
 
306
  if (temp < YY_PART_YEAR - 1)
 
307
  {
 
308
    *to++= '2';
 
309
    *to++= '0';
 
310
  }
 
311
  else
 
312
  {
 
313
    *to++= '1';
 
314
    *to++= '9';
 
315
  }
 
316
  temp2=temp/10; temp=temp-temp2*10;
 
317
  *to++= (char) ('0'+(char) (temp2));
 
318
  *to++= (char) ('0'+(char) (temp));
 
319
  *to++= '-';
 
320
  temp=time_tmp.month;
 
321
  temp2=temp/10; temp=temp-temp2*10;
 
322
  *to++= (char) ('0'+(char) (temp2));
 
323
  *to++= (char) ('0'+(char) (temp));
 
324
  *to++= '-';
 
325
  temp=time_tmp.day;
 
326
  temp2=temp/10; temp=temp-temp2*10;
 
327
  *to++= (char) ('0'+(char) (temp2));
 
328
  *to++= (char) ('0'+(char) (temp));
 
329
  *to++= ' ';
 
330
  temp=time_tmp.hour;
 
331
  temp2=temp/10; temp=temp-temp2*10;
 
332
  *to++= (char) ('0'+(char) (temp2));
 
333
  *to++= (char) ('0'+(char) (temp));
 
334
  *to++= ':';
 
335
  temp=time_tmp.minute;
 
336
  temp2=temp/10; temp=temp-temp2*10;
 
337
  *to++= (char) ('0'+(char) (temp2));
 
338
  *to++= (char) ('0'+(char) (temp));
 
339
  *to++= ':';
 
340
  temp=time_tmp.second;
 
341
  temp2=temp/10; temp=temp-temp2*10;
 
342
  *to++= (char) ('0'+(char) (temp2));
 
343
  *to++= (char) ('0'+(char) (temp));
 
344
  *to= 0;
275
345
  return val_buffer;
276
346
}
277
347
 
278
 
bool Field_timestamp::get_date(DRIZZLE_TIME *ltime, uint32_t)
 
348
 
 
349
bool Field_timestamp::get_date(MYSQL_TIME *ltime, uint fuzzydate)
279
350
{
280
 
  uint32_t temp;
281
 
 
 
351
  long temp;
 
352
  THD *thd= table ? table->in_use : current_thd;
 
353
  thd->time_zone_used= 1;
282
354
#ifdef WORDS_BIGENDIAN
283
355
  if (table && table->s->db_low_byte_first)
284
 
    temp= uint4korr(ptr);
 
356
    temp=uint4korr(ptr);
285
357
  else
286
358
#endif
287
 
    longget(temp, ptr);
288
 
  
289
 
  memset(ltime, 0, sizeof(*ltime));
290
 
 
291
 
  drizzled::Timestamp temporal;
292
 
  (void) temporal.from_time_t((time_t) temp);
293
 
 
294
 
  /* @TODO Goodbye the below code when DRIZZLE_TIME is finally gone.. */
295
 
 
296
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
297
 
  ltime->year= temporal.years();
298
 
  ltime->month= temporal.months();
299
 
  ltime->day= temporal.days();
300
 
  ltime->hour= temporal.hours();
301
 
  ltime->minute= temporal.minutes();
302
 
  ltime->second= temporal.seconds();
303
 
 
 
359
    longget(temp,ptr);
 
360
  if (temp == 0L)
 
361
  {                                   /* Zero time is "000000" */
 
362
    if (fuzzydate & TIME_NO_ZERO_DATE)
 
363
      return 1;
 
364
    bzero((char*) ltime,sizeof(*ltime));
 
365
  }
 
366
  else
 
367
  {
 
368
    thd->variables.time_zone->gmt_sec_to_TIME(ltime, (my_time_t)temp);
 
369
  }
304
370
  return 0;
305
371
}
306
372
 
307
 
bool Field_timestamp::get_time(DRIZZLE_TIME *ltime)
 
373
bool Field_timestamp::get_time(MYSQL_TIME *ltime)
308
374
{
309
375
  return Field_timestamp::get_date(ltime,0);
310
376
}
311
377
 
312
 
int Field_timestamp::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
378
 
 
379
bool Field_timestamp::send_binary(Protocol *protocol)
 
380
{
 
381
  MYSQL_TIME tm;
 
382
  Field_timestamp::get_date(&tm, 0);
 
383
  return protocol->store(&tm);
 
384
}
 
385
 
 
386
 
 
387
int Field_timestamp::cmp(const uchar *a_ptr, const uchar *b_ptr)
313
388
{
314
389
  int32_t a,b;
315
390
#ifdef WORDS_BIGENDIAN
328
403
}
329
404
 
330
405
 
331
 
void Field_timestamp::sort_string(unsigned char *to,uint32_t )
 
406
void Field_timestamp::sort_string(uchar *to,uint length __attribute__((unused)))
332
407
{
333
408
#ifdef WORDS_BIGENDIAN
334
409
  if (!table || !table->s->db_low_byte_first)
348
423
  }
349
424
}
350
425
 
 
426
 
351
427
void Field_timestamp::sql_type(String &res) const
352
428
{
353
429
  res.set_ascii(STRING_WITH_LEN("timestamp"));
354
430
}
355
431
 
 
432
 
356
433
void Field_timestamp::set_time()
357
434
{
358
 
  Session *session= table ? table->in_use : current_session;
359
 
  long tmp= (long) session->query_start();
 
435
  THD *thd= table ? table->in_use : current_thd;
 
436
  long tmp= (long) thd->query_start();
360
437
  set_notnull();
361
438
  store_timestamp(tmp);
362
439
}
363
440
 
364
 
void Field_timestamp::set_default()
365
 
{
366
 
  if (table->timestamp_field == this &&
367
 
      unireg_check != TIMESTAMP_UN_FIELD)
368
 
    set_time();
369
 
  else
370
 
    Field::set_default();
371
 
}
372
 
 
373
 
long Field_timestamp::get_timestamp(bool *null_value)
374
 
{
375
 
  if ((*null_value= is_null()))
376
 
    return 0;
377
 
#ifdef WORDS_BIGENDIAN
378
 
  if (table && table->s->db_low_byte_first)
379
 
    return sint4korr(ptr);
380
 
#endif
381
 
  long tmp;
382
 
  longget(tmp,ptr);
383
 
  return tmp;
384
 
}
385
 
 
386
 
void Field_timestamp::store_timestamp(time_t timestamp)
387
 
{
388
 
#ifdef WORDS_BIGENDIAN
389
 
  if (table && table->s->db_low_byte_first)
390
 
  {
391
 
    int4store(ptr,timestamp);
392
 
  }
393
 
  else
394
 
#endif
395
 
    longstore(ptr,(uint32_t) timestamp);
396
 
}