← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/time_functions.cc

  • Committer: Mark Atwood
  • Date: 2011-10-08 04:50:51 UTC
  • mfrom: (2430.1.1 rf)
  • Revision ID: me@mark.atwood.name-20111008045051-6ha1qiy7k2a9c3jv
Tags: 2011.10.27
merge lp:~olafvdspek/drizzle/refactor2

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/time_functions.cc
125
125
}
126
126
 
127
127
 
128
 
type::timestamp_t str_to_datetime_with_warn(Session& session, str_ref str, type::Time& l_time, uint32_t flags)
 
128
type::timestamp_t str_to_datetime_with_warn(Session *session,
 
129
                                            const char *str, 
 
130
                                            uint32_t length, 
 
131
                                            type::Time *l_time,
 
132
                                            uint32_t flags)
129
133
{
130
134
  type::cut_t was_cut= type::VALID;
131
 
  type::timestamp_t ts_type= l_time.store(str.data(), str.size(), (flags | (session.variables.sql_mode & (MODE_INVALID_DATES | MODE_NO_ZERO_DATE))), was_cut);
 
135
  type::timestamp_t ts_type;
 
136
 
 
137
  ts_type= l_time->store(str, length,
 
138
                         (flags | (session->variables.sql_mode &
 
139
                                   (MODE_INVALID_DATES |
 
140
                                    MODE_NO_ZERO_DATE))),
 
141
                         was_cut);
132
142
  if (was_cut || ts_type <= type::DRIZZLE_TIMESTAMP_ERROR)
133
 
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, str, ts_type,  NULL);
 
143
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
144
                                 str, length, ts_type,  NULL);
 
145
 
134
146
  return ts_type;
135
147
}
136
148
 
137
149
 
138
 
bool str_to_time_with_warn(Session& session, str_ref str, type::Time& l_time)
 
150
bool
 
151
str_to_time_with_warn(Session *session, const char *str, uint32_t length, type::Time *l_time)
139
152
{
140
153
  int warning;
141
 
  bool ret_val= l_time.store(str.data(), str.size(), warning, type::DRIZZLE_TIMESTAMP_TIME);
 
154
  bool ret_val= l_time->store(str, length, warning, type::DRIZZLE_TIMESTAMP_TIME);
142
155
  if (ret_val || warning)
143
 
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, str, type::DRIZZLE_TIMESTAMP_TIME, NULL);
 
156
    make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
157
                                 str, length, type::DRIZZLE_TIMESTAMP_TIME, NULL);
144
158
  return ret_val;
145
159
}
146
160
 
147
161
 
148
 
void make_truncated_value_warning(Session& session, DRIZZLE_ERROR::enum_warning_level level, str_ref str_arg, type::timestamp_t time_type, const char *field_name)
 
162
void make_truncated_value_warning(Session *session, 
 
163
                                  DRIZZLE_ERROR::enum_warning_level level,
 
164
                                  const char *str_val,
 
165
                                                          uint32_t str_length,
 
166
                                  type::timestamp_t time_type,
 
167
                                  const char *field_name)
149
168
{
150
169
  char warn_buff[DRIZZLE_ERRMSG_SIZE];
 
170
  const char *type_str;
151
171
  charset_info_st *cs= &my_charset_utf8_general_ci;
152
172
  char buff[128];
153
173
  String str(buff,(uint32_t) sizeof(buff), system_charset_info);
154
 
  str.copy(str_arg.data(), str_arg.size(), system_charset_info);
155
 
  assert(not str[str_arg.size()]);               // Ensure we have end 0 for snprintf
 
174
  str.copy(str_val, str_length, system_charset_info);
 
175
  str[str_length]= 0;               // Ensure we have end 0 for snprintf
156
176
 
157
 
  const char *type_str;
158
 
  switch (time_type) 
159
 
  {
 
177
  switch (time_type) {
160
178
  case type::DRIZZLE_TIMESTAMP_DATE:
161
179
    type_str= "date";
162
180
    break;
168
186
  case type::DRIZZLE_TIMESTAMP_DATETIME:  // FALLTHROUGH
169
187
  default:
170
188
    type_str= "datetime";
 
189
    break;
171
190
  }
172
191
 
173
192
  if (field_name)
175
194
    cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
176
195
                       ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
177
196
                       type_str, str.c_ptr(), field_name,
178
 
                       (uint32_t) session.row_count);
179
 
  }
180
 
  else if (time_type > type::DRIZZLE_TIMESTAMP_ERROR)
181
 
  {
182
 
    cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff), ER(ER_TRUNCATED_WRONG_VALUE), type_str, str.c_ptr());
 
197
                       (uint32_t) session->row_count);
183
198
  }
184
199
  else
185
200
  {
186
 
    cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff), ER(ER_WRONG_VALUE), type_str, str.c_ptr());
 
201
    if (time_type > type::DRIZZLE_TIMESTAMP_ERROR)
 
202
    {
 
203
      cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
 
204
                         ER(ER_TRUNCATED_WRONG_VALUE),
 
205
                         type_str, str.c_ptr());
 
206
    }
 
207
    else
 
208
    {
 
209
      cs->cset->snprintf(cs, warn_buff, sizeof(warn_buff),
 
210
                         ER(ER_WRONG_VALUE), type_str, str.c_ptr());
 
211
    }
187
212
  }
188
 
  push_warning(&session, level, ER_TRUNCATED_WRONG_VALUE, warn_buff);
 
213
  push_warning(session, level,
 
214
               ER_TRUNCATED_WRONG_VALUE, warn_buff);
189
215
}
190
216
 
191
217