← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/str.cc

Reverted 1103

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;
102
97
    !=0  error
103
98
*/
104
99
 
105
 
int Field_str::store_decimal(const type::Decimal *d)
 
100
int Field_str::store_decimal(const my_decimal *d)
106
101
{
107
102
  char buff[DECIMAL_MAX_STR_LENGTH+1];
108
103
  String str(buff, sizeof(buff), &my_charset_bin);
109
 
  class_decimal2string(d, 0, &str);
 
104
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
110
105
  return store(str.ptr(), str.length(), str.charset());
111
106
}
112
107
 
113
 
type::Decimal *Field_str::val_decimal(type::Decimal *decimal_value)
 
108
my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
114
109
{
115
110
  int64_t nr= val_int();
116
 
  int2_class_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
 
111
  int2my_decimal(E_DEC_FATAL_ERROR, nr, 0, decimal_value);
117
112
  return decimal_value;
118
113
}
119
114
 
134
129
 
135
130
  ASSERT_COLUMN_MARKED_FOR_WRITE;
136
131
 
137
 
  length= internal::my_gcvt(nr, internal::MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
 
132
  length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
138
133
  if (error)
139
134
  {
140
 
    if (getTable()->getSession()->abortOnWarning())
141
 
    {
 
135
    if (table->in_use->abort_on_warning)
142
136
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
143
 
    }
144
137
    else
145
 
    {
146
138
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
147
 
    }
148
139
  }
149
140
  return store(buff, length, charset());
150
141
}
151
142
 
 
143
/* If one of the fields is binary and the other one isn't return 1 else 0 */
 
144
 
 
145
bool Field_str::compare_str_field_flags(CreateField *new_field_ptr,
 
146
                                        uint32_t flag_arg)
 
147
{
 
148
  return (((new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
 
149
          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
 
150
         (!(new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
 
151
          (flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
 
152
}
 
153
 
 
154
 
 
155
uint32_t Field_str::is_equal(CreateField *new_field_ptr)
 
156
{
 
157
  if (compare_str_field_flags(new_field_ptr, flags))
 
158
    return 0;
 
159
 
 
160
  return ((new_field_ptr->sql_type == real_type()) &&
 
161
          new_field_ptr->charset == field_charset &&
 
162
          new_field_ptr->length == max_display_length());
 
163
}
 
164
 
152
165
 
153
166
bool check_string_copy_error(Field_str *field,
154
167
                             const char *well_formed_error_pos,
187
200
    {
188
201
      *t++= '\\';
189
202
      *t++= 'x';
190
 
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) >> 4];
191
 
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) & 15];
 
203
      *t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
 
204
      *t++= _dig_vec_upper[((unsigned char) *pos) & 15];
192
205
    }
193
206
  }
194
207
  if (end_orig > end)
198
211
    *t++= '.';
199
212
  }
200
213
  *t= '\0';
201
 
  push_warning_printf(field->getTable()->in_use,
202
 
                      field->getTable()->in_use->abortOnWarning() ?
 
214
  push_warning_printf(field->table->in_use,
 
215
                      field->table->in_use->abort_on_warning ?
203
216
                      DRIZZLE_ERROR::WARN_LEVEL_ERROR :
204
217
                      DRIZZLE_ERROR::WARN_LEVEL_WARN,
205
218
                      ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
206
219
                      ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
207
220
                      "string", tmp, field->field_name,
208
 
                      (uint32_t) field->getTable()->in_use->row_count);
 
221
                      (uint32_t) field->table->in_use->row_count);
209
222
  return true;
210
223
}
211
224
 
214
227
  return field_length + (field_length > 255 ? 2 : 1);
215
228
}
216
229
 
217
 
} /* namespace drizzled */