← 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-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

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