← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/microtime.cc

  • Committer: Brian Aker
  • Date: 2011-01-05 17:21:13 UTC
  • mto: (2057.2.1 clean)
  • mto: This revision was merged to the branch mainline in revision 2064.
  • Revision ID: brian@tangent.org-20110105172113-s7mng3puod6o9n3y
Add basic tests for microtime.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/microtime.cc
37
37
 
38
38
namespace field
39
39
{
 
40
 
 
41
static boost::posix_time::ptime epoch(boost::gregorian::date(1970, 1, 1));
 
42
 
40
43
Microtime::Microtime(unsigned char *ptr_arg,
41
44
                     unsigned char *null_ptr_arg,
42
45
                     unsigned char null_bit_arg,
60
63
}
61
64
 
62
65
int Microtime::store(const char *from,
63
 
                 uint32_t len,
64
 
                 const CHARSET_INFO * const )
 
66
                     uint32_t len,
 
67
                     const CHARSET_INFO * const )
65
68
{
66
 
  Timestamp temporal;
 
69
  MicroTimestamp temporal;
67
70
 
68
71
  ASSERT_COLUMN_MARKED_FOR_WRITE;
69
72
 
73
76
    return 1;
74
77
  }
75
78
 
76
 
  time_t tmp;
77
 
  temporal.to_time_t(tmp);
78
 
 
79
 
  pack_num(tmp);
 
79
  struct timeval tmp;
 
80
  temporal.to_timeval(tmp);
 
81
 
 
82
  uint64_t tmp_seconds= tmp.tv_sec;
 
83
  uint32_t tmp_micro= tmp.tv_sec;
 
84
 
 
85
  pack_num(tmp_seconds);
 
86
  pack_num(tmp_micro, ptr +8);
 
87
 
80
88
  return 0;
81
89
}
82
90
 
103
111
{
104
112
  ASSERT_COLUMN_MARKED_FOR_WRITE;
105
113
 
106
 
  /* 
107
 
   * Try to create a DateTime from the supplied integer.  Throw an error
108
 
   * if unable to create a valid DateTime.  
109
 
   */
110
 
  Timestamp temporal;
111
 
  if (! temporal.from_int64_t(from))
 
114
  MicroTimestamp temporal;
 
115
  if (not temporal.from_int64_t(from))
112
116
  {
113
117
    /* Convert the integer to a string using boost::lexical_cast */
114
118
    std::string tmp(boost::lexical_cast<std::string>(from));
120
124
  time_t tmp;
121
125
  temporal.to_time_t(tmp);
122
126
 
123
 
  pack_num(tmp);
 
127
  uint64_t tmp_micro= tmp;
 
128
  pack_num(tmp_micro);
 
129
  pack_num(static_cast<uint32_t>(0), ptr +8);
124
130
 
125
131
  return 0;
126
132
}
144
150
  /* We must convert into a "timestamp-formatted integer" ... */
145
151
  int64_t result;
146
152
  temporal.to_int64_t(&result);
 
153
 
147
154
  return result;
148
155
}
149
156
 
150
157
String *Microtime::val_str(String *val_buffer, String *)
151
158
{
152
159
  uint64_t temp= 0;
 
160
  uint32_t micro_temp= 0;
153
161
  char *to;
154
162
  int to_len= field_length + 1;
155
163
 
157
165
  to= (char *) val_buffer->ptr();
158
166
 
159
167
  unpack_num(temp);
 
168
  unpack_num(micro_temp, ptr +8);
160
169
 
161
170
  val_buffer->set_charset(&my_charset_bin);     /* Safety */
162
171
 
163
 
  Timestamp temporal;
164
 
  (void) temporal.from_time_t((time_t) temp);
 
172
  struct timeval buffer;
 
173
  buffer.tv_sec= temp;
 
174
  buffer.tv_usec= micro_temp;
 
175
 
 
176
  MicroTimestamp temporal;
 
177
  (void) temporal.from_timeval(buffer);
165
178
 
166
179
  int rlen;
167
180
  rlen= temporal.to_string(to, to_len);
 
181
  std::cerr << "->" << rlen << " < " << to_len << std::endl;
168
182
  assert(rlen < to_len);
169
183
 
170
184
  val_buffer->length(rlen);
174
188
bool Microtime::get_date(type::Time *ltime, uint32_t)
175
189
{
176
190
  uint64_t temp;
 
191
  uint32_t micro_temp= 0;
177
192
 
178
193
  unpack_num(temp);
 
194
  unpack_num(micro_temp, ptr +8);
179
195
  
180
196
  memset(ltime, 0, sizeof(*ltime));
181
197
 
191
207
  ltime->hour= temporal.hours();
192
208
  ltime->minute= temporal.minutes();
193
209
  ltime->second= temporal.seconds();
 
210
  ltime->second_part= temporal.useconds();
194
211
 
195
212
  return 0;
196
213
}
203
220
int Microtime::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
204
221
{
205
222
  uint64_t a,b;
 
223
  uint32_t a_micro, b_micro;
206
224
 
207
225
  unpack_num(a, a_ptr);
 
226
  unpack_num(a_micro, a_ptr +8);
 
227
 
208
228
  unpack_num(b, b_ptr);
 
229
  unpack_num(b_micro, b_ptr +8);
 
230
 
 
231
  if (a == b)
 
232
    return (a_micro < b_micro) ? -1 : (a_micro > b_micro) ? 1 : 0;
209
233
 
210
234
  return (a < b) ? -1 : (a > b) ? 1 : 0;
211
235
}
217
241
  if ((not getTable()) or (not getTable()->getShare()->db_low_byte_first))
218
242
  {
219
243
    std::reverse_copy(to, to+pack_length(), ptr);
 
244
    std::reverse_copy(to +8, to+pack_length(), ptr +8);
220
245
  }
221
246
  else
222
247
#endif
235
260
  Session *session= getTable() ? getTable()->in_use : current_session;
236
261
  time_t tmp= session->query_start();
237
262
  set_notnull();
238
 
  pack_num(tmp);
239
 
}
240
263
 
241
 
void Microtime::set_default()
242
 
{
243
 
  if (getTable()->timestamp_field == this &&
244
 
      unireg_check != TIMESTAMP_UN_FIELD)
245
 
  {
246
 
    set_time();
247
 
  }
248
 
  else
249
 
  {
250
 
    Field::set_default();
251
 
  }
 
264
  uint64_t tmp_micro= tmp;
 
265
  pack_num(tmp_micro);
 
266
  pack_num(static_cast<uint32_t>(0), ptr +8);
252
267
}
253
268
 
254
269
long Microtime::get_timestamp(bool *null_value)