← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/str.cc

  • Committer: Stewart Smith
  • Date: 2009-06-17 06:44:38 UTC
  • mto: This revision was merged to the branch mainline in revision 1094.
  • Revision ID: stewart@flamingspork.com-20090617064438-062owpgtdzgr4lvx
type_float.test for MyISAM as temp only

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/str.cc
19
19
 */
20
20
 
21
21
 
22
 
#include "config.h"
 
22
#include <drizzled/server_includes.h>
23
23
#include <drizzled/field/str.h>
24
24
#include <drizzled/error.h>
25
25
#include <drizzled/table.h>
26
26
#include <drizzled/session.h>
27
 
#include "drizzled/internal/m_string.h"
28
 
 
29
 
namespace drizzled
30
 
{
31
 
 
32
 
namespace internal
33
 
{
34
 
extern char _dig_vec_upper[];
35
 
}
36
 
 
37
 
Field_str::Field_str(unsigned char *ptr_arg,
38
 
                     uint32_t len_arg,
 
27
 
 
28
 
 
29
Field_str::Field_str(unsigned char *ptr_arg,uint32_t len_arg,
39
30
                     unsigned char *null_ptr_arg,
40
 
                     unsigned char null_bit_arg,
 
31
                     unsigned char null_bit_arg, utype unireg_check_arg,
41
32
                     const char *field_name_arg,
42
33
                     const CHARSET_INFO * const charset_arg)
43
 
  :Field(ptr_arg, len_arg,
44
 
         null_ptr_arg,
45
 
         null_bit_arg,
46
 
         Field::NONE,
47
 
         field_name_arg)
 
34
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
35
         unireg_check_arg, field_name_arg)
48
36
{
49
37
  field_charset= charset_arg;
50
38
  if (charset_arg->state & MY_CS_BINSORT)
51
 
    flags|= BINARY_FLAG;
 
39
    flags|=BINARY_FLAG;
52
40
  field_derivation= DERIVATION_IMPLICIT;
53
41
}
54
42
 
73
61
int
74
62
Field_str::report_if_important_data(const char *field_ptr, const char *end)
75
63
{
76
 
  if ((field_ptr < end) && getTable()->in_use->count_cuted_fields)
 
64
  if ((field_ptr < end) && table->in_use->count_cuted_fields)
77
65
  {
78
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
79
 
 
 
66
    if (test_if_important_data(field_charset, field_ptr, end))
 
67
    {
 
68
      if (table->in_use->abort_on_warning)
 
69
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
 
70
      else
 
71
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
72
    }
 
73
    else /* If we lost only spaces then produce a NOTE, not a WARNING */
 
74
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
80
75
    return 2;
81
76
  }
82
77
  return 0;
132
127
  size_t length;
133
128
  bool error;
134
129
 
135
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
136
 
 
137
 
  length= internal::my_gcvt(nr, internal::MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
 
130
  length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
138
131
  if (error)
139
132
  {
140
 
    if (getTable()->in_use->abort_on_warning)
 
133
    if (table->in_use->abort_on_warning)
141
134
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
142
135
    else
143
136
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
145
138
  return store(buff, length, charset());
146
139
}
147
140
 
 
141
/* If one of the fields is binary and the other one isn't return 1 else 0 */
 
142
 
 
143
bool Field_str::compare_str_field_flags(CreateField *new_field_ptr,
 
144
                                        uint32_t flag_arg)
 
145
{
 
146
  return (((new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
 
147
          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
 
148
         (!(new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
 
149
          (flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
 
150
}
 
151
 
 
152
 
 
153
uint32_t Field_str::is_equal(CreateField *new_field_ptr)
 
154
{
 
155
  if (compare_str_field_flags(new_field_ptr, flags))
 
156
    return 0;
 
157
 
 
158
  return ((new_field_ptr->sql_type == real_type()) &&
 
159
          new_field_ptr->charset == field_charset &&
 
160
          new_field_ptr->length == max_display_length());
 
161
}
 
162
 
148
163
 
149
164
bool check_string_copy_error(Field_str *field,
150
165
                             const char *well_formed_error_pos,
183
198
    {
184
199
      *t++= '\\';
185
200
      *t++= 'x';
186
 
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) >> 4];
187
 
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) & 15];
 
201
      *t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
 
202
      *t++= _dig_vec_upper[((unsigned char) *pos) & 15];
188
203
    }
189
204
  }
190
205
  if (end_orig > end)
194
209
    *t++= '.';
195
210
  }
196
211
  *t= '\0';
197
 
  push_warning_printf(field->getTable()->in_use,
198
 
                      field->getTable()->in_use->abort_on_warning ?
 
212
  push_warning_printf(field->table->in_use,
 
213
                      field->table->in_use->abort_on_warning ?
199
214
                      DRIZZLE_ERROR::WARN_LEVEL_ERROR :
200
215
                      DRIZZLE_ERROR::WARN_LEVEL_WARN,
201
216
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
202
217
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
203
218
                      "string", tmp, field->field_name,
204
 
                      (uint32_t) field->getTable()->in_use->row_count);
 
219
                      (uint32_t) field->table->in_use->row_count);
205
220
  return true;
206
221
}
207
222
 
210
225
  return field_length + (field_length > 255 ? 2 : 1);
211
226
}
212
227
 
213
 
} /* namespace drizzled */