← 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-12-11 22:56:39 UTC
  • mfrom: (2465.1.1 drizzle)
  • Revision ID: me@mark.atwood.name-20111211225639-3d8ype7g2y82dci5
merge lp:~brianaker/drizzle/libdrizzle-breakout

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