← 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-19 18:03:32 UTC
  • mfrom: (2088.8.12 timestamp)
  • mto: This revision was merged to the branch mainline in revision 2098.
  • Revision ID: brian@tangent.org-20110119180332-acfk5i8oofp63s40
Merge in time code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/microtime.cc
54
54
        unireg_check_arg,
55
55
        field_name_arg,
56
56
        share)
57
 
  {
58
 
  }
 
57
{
 
58
}
59
59
 
60
60
Microtime::Microtime(bool maybe_null_arg,
61
61
                     const char *field_name_arg) :
74
74
 
75
75
  if (not temporal.from_string(from, (size_t) len))
76
76
  {
77
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
 
77
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), from);
78
78
    return 1;
79
79
  }
80
80
 
90
90
  return 0;
91
91
}
92
92
 
93
 
int Microtime::store_time(type::Time *ltime, enum enum_drizzle_timestamp_type )
 
93
int Microtime::store_time(type::Time *ltime, type::timestamp_t )
94
94
{
95
95
  long my_timezone;
96
96
  bool in_dst_time_gap;
97
97
 
98
 
  time_t time_tmp= my_system_gmt_sec(ltime, &my_timezone, &in_dst_time_gap, true);
 
98
  type::Time::epoch_t time_tmp= my_system_gmt_sec(ltime, &my_timezone, &in_dst_time_gap, true);
99
99
  uint64_t tmp_seconds= time_tmp;
100
100
  uint32_t tmp_micro= ltime->second_part;
101
101
 
109
109
{
110
110
  ASSERT_COLUMN_MARKED_FOR_WRITE;
111
111
 
112
 
  if (from < 0 || from > 99991231235959.0)
 
112
  uint64_t from_tmp= (uint64_t)from;
 
113
  type::Time::usec_t fractional_seconds= (type::Time::usec_t)((from - from_tmp) * type::Time::FRACTIONAL_DIGITS) % type::Time::FRACTIONAL_DIGITS;
 
114
 
 
115
  MicroTimestamp temporal;
 
116
  if (not temporal.from_int64_t(from_tmp))
113
117
  {
114
 
    /* Convert the double to a string using stringstream */
115
 
    std::stringstream ss;
116
 
    std::string tmp;
117
 
    ss.precision(18); /* 18 places should be fine for error display of double input. */
118
 
    ss << from; 
119
 
    ss >> tmp;
 
118
    /* Convert the integer to a string using boost::lexical_cast */
 
119
    std::string tmp(boost::lexical_cast<std::string>(from));
120
120
 
121
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
 
121
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
122
122
    return 2;
123
123
  }
124
 
  return Microtime::store((int64_t) rint(from), false);
 
124
 
 
125
  time_t tmp;
 
126
  temporal.to_time_t(tmp);
 
127
 
 
128
  uint64_t tmp_micro= tmp;
 
129
  pack_num(tmp_micro);
 
130
  pack_num(fractional_seconds, ptr +8);
 
131
 
 
132
  return 0;
125
133
}
126
134
 
127
135
int Microtime::store(int64_t from, bool)
134
142
    /* Convert the integer to a string using boost::lexical_cast */
135
143
    std::string tmp(boost::lexical_cast<std::string>(from));
136
144
 
137
 
    my_error(ER_INVALID_UNIX_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
 
145
    my_error(ER_INVALID_TIMESTAMP_VALUE, MYF(ME_FATALERROR), tmp.c_str());
138
146
    return 2;
139
147
  }
140
148
 
150
158
 
151
159
double Microtime::val_real(void)
152
160
{
153
 
  return (double) Microtime::val_int();
 
161
  uint64_t temp;
 
162
  type::Time::usec_t micro_temp;
 
163
 
 
164
  ASSERT_COLUMN_MARKED_FOR_READ;
 
165
 
 
166
  unpack_num(temp);
 
167
  unpack_num(micro_temp, ptr +8);
 
168
 
 
169
  Timestamp temporal;
 
170
  (void) temporal.from_time_t((time_t) temp);
 
171
 
 
172
  /* We must convert into a "timestamp-formatted integer" ... */
 
173
  int64_t result;
 
174
  temporal.to_int64_t(&result);
 
175
 
 
176
  result+= micro_temp % type::Time::FRACTIONAL_DIGITS;
 
177
 
 
178
  return result;
 
179
}
 
180
 
 
181
type::Decimal *Microtime::val_decimal(type::Decimal *decimal_value)
 
182
{
 
183
  type::Time ltime;
 
184
 
 
185
  get_date(&ltime, 0);
 
186
 
 
187
  return date2_class_decimal(&ltime, decimal_value);
154
188
}
155
189
 
156
190
int64_t Microtime::val_int(void)
174
208
String *Microtime::val_str(String *val_buffer, String *)
175
209
{
176
210
  uint64_t temp= 0;
177
 
  uint32_t micro_temp= 0;
178
 
  char *to;
179
 
  int to_len= field_length + 1 + 8;
180
 
 
181
 
  val_buffer->alloc(to_len);
182
 
  to= (char *) val_buffer->ptr();
 
211
  type::Time::usec_t micro_temp= 0;
183
212
 
184
213
  unpack_num(temp);
185
214
  unpack_num(micro_temp, ptr +8);
186
215
 
187
 
  val_buffer->set_charset(&my_charset_bin);     /* Safety */
188
 
 
189
 
  struct timeval buffer;
190
 
  buffer.tv_sec= temp;
191
 
  buffer.tv_usec= micro_temp;
192
 
 
193
 
  MicroTimestamp temporal;
194
 
  (void) temporal.from_timeval(buffer);
195
 
 
196
 
  int rlen= temporal.to_string(to, to_len);
197
 
  assert(rlen <= to_len);
198
 
 
199
 
  val_buffer->length(rlen);
 
216
  type::Time tmp_time;
 
217
  tmp_time.store(temp, micro_temp);
 
218
 
 
219
  tmp_time.convert(*val_buffer);
 
220
 
200
221
 
201
222
  return val_buffer;
202
223
}
209
230
  unpack_num(temp);
210
231
  unpack_num(micro_temp, ptr +8);
211
232
  
212
 
  memset(ltime, 0, sizeof(*ltime));
213
 
 
214
 
  Timestamp temporal;
215
 
  (void) temporal.from_time_t((time_t) temp);
216
 
 
217
 
  /* @TODO Goodbye the below code when type::Time is finally gone.. */
218
 
 
219
 
  ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
220
 
  ltime->year= temporal.years();
221
 
  ltime->month= temporal.months();
222
 
  ltime->day= temporal.days();
223
 
  ltime->hour= temporal.hours();
224
 
  ltime->minute= temporal.minutes();
225
 
  ltime->second= temporal.seconds();
226
 
  ltime->second_part= temporal.useconds();
227
 
 
228
 
  return 0;
 
233
  ltime->reset();
 
234
 
 
235
  ltime->store(temp, micro_temp);
 
236
 
 
237
  return false;
229
238
}
230
239
 
231
240
bool Microtime::get_time(type::Time *ltime)
232
241
{
233
 
  return Microtime::get_date(ltime,0);
 
242
  return Microtime::get_date(ltime, 0);
234
243
}
235
244
 
236
245
int Microtime::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
275
284
{
276
285
  Session *session= getTable() ? getTable()->in_use : current_session;
277
286
 
278
 
  uint32_t fractional_seconds= 0;
 
287
  type::Time::usec_t fractional_seconds= 0;
279
288
  uint64_t epoch_seconds= session->getCurrentTimestampEpoch(fractional_seconds);
280
289
 
281
290
  set_notnull();