← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/str.cc

  • Committer: Brian Aker
  • Date: 2010-04-05 23:46:43 UTC
  • Revision ID: brian@gaz-20100405234643-0he3xnj902rc70r8
Fixing tests to work with PBXT.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/str.cc
19
19
 */
20
20
 
21
21
 
22
 
#include <drizzled/server_includes.h>
 
22
#include "config.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
 
 
28
 
 
29
 
Field_str::Field_str(unsigned char *ptr_arg,uint32_t len_arg,
 
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,
30
39
                     unsigned char *null_ptr_arg,
31
 
                     unsigned char null_bit_arg, utype unireg_check_arg,
 
40
                     unsigned char null_bit_arg,
32
41
                     const char *field_name_arg,
33
42
                     const CHARSET_INFO * const charset_arg)
34
 
  :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
35
 
         unireg_check_arg, field_name_arg)
 
43
  :Field(ptr_arg, len_arg,
 
44
         null_ptr_arg,
 
45
         null_bit_arg,
 
46
         Field::NONE,
 
47
         field_name_arg)
36
48
{
37
49
  field_charset= charset_arg;
38
50
  if (charset_arg->state & MY_CS_BINSORT)
39
 
    flags|=BINARY_FLAG;
 
51
    flags|= BINARY_FLAG;
40
52
  field_derivation= DERIVATION_IMPLICIT;
41
53
}
42
54
 
 
55
/*
 
56
  Check if we lost any important data and send a truncation error/warning
 
57
 
 
58
  SYNOPSIS
 
59
    Field_str::report_if_important_data()
 
60
    ptr                      - Truncated rest of string
 
61
    end                      - End of truncated string
 
62
 
 
63
  RETURN VALUES
 
64
    0   - None was truncated (or we don't count cut fields)
 
65
    2   - Some bytes was truncated
 
66
 
 
67
  NOTE
 
68
    Check if we lost any important data (anything in a binary string,
 
69
    or any non-space in others). If only trailing spaces was lost,
 
70
    send a truncation note, otherwise send a truncation error.
 
71
*/
 
72
 
 
73
int
 
74
Field_str::report_if_important_data(const char *field_ptr, const char *end)
 
75
{
 
76
  if ((field_ptr < end) && table->in_use->count_cuted_fields)
 
77
  {
 
78
    if (test_if_important_data(field_charset, field_ptr, end))
 
79
    {
 
80
      if (table->in_use->abort_on_warning)
 
81
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_ERROR, ER_DATA_TOO_LONG, 1);
 
82
      else
 
83
        set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
 
84
    }
 
85
    else /* If we lost only spaces then produce a NOTE, not a WARNING */
 
86
      set_warning(DRIZZLE_ERROR::WARN_LEVEL_NOTE, ER_WARN_DATA_TRUNCATED, 1);
 
87
    return 2;
 
88
  }
 
89
  return 0;
 
90
}
 
91
 
43
92
/**
44
93
  Decimal representation of Field_str.
45
94
 
62
111
 
63
112
int Field_str::store_decimal(const my_decimal *d)
64
113
{
65
 
  double val;
66
 
  /* TODO: use decimal2string? */
67
 
  int err= warn_if_overflow(my_decimal2double(E_DEC_FATAL_ERROR &
68
 
                                            ~E_DEC_OVERFLOW, d, &val));
69
 
  return err | store(val);
 
114
  char buff[DECIMAL_MAX_STR_LENGTH+1];
 
115
  String str(buff, sizeof(buff), &my_charset_bin);
 
116
  my_decimal2string(E_DEC_FATAL_ERROR, d, 0, 0, 0, &str);
 
117
  return store(str.ptr(), str.length(), str.charset());
70
118
}
71
119
 
72
120
my_decimal *Field_str::val_decimal(my_decimal *decimal_value)
91
139
  size_t length;
92
140
  bool error;
93
141
 
94
 
  length= my_gcvt(nr, MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
 
142
  ASSERT_COLUMN_MARKED_FOR_WRITE;
 
143
 
 
144
  length= internal::my_gcvt(nr, internal::MY_GCVT_ARG_DOUBLE, local_char_length, buff, &error);
95
145
  if (error)
96
146
  {
97
147
    if (table->in_use->abort_on_warning)
102
152
  return store(buff, length, charset());
103
153
}
104
154
 
105
 
/* If one of the fields is binary and the other one isn't return 1 else 0 */
106
 
 
107
 
bool Field_str::compare_str_field_flags(Create_field *new_field_ptr,
108
 
                                        uint32_t flag_arg)
109
 
{
110
 
  return (((new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
111
 
          !(flag_arg & (BINCMP_FLAG | BINARY_FLAG))) ||
112
 
         (!(new_field_ptr->flags & (BINCMP_FLAG | BINARY_FLAG)) &&
113
 
          (flag_arg & (BINCMP_FLAG | BINARY_FLAG))));
114
 
}
115
 
 
116
 
 
117
 
uint32_t Field_str::is_equal(Create_field *new_field_ptr)
118
 
{
119
 
  if (compare_str_field_flags(new_field_ptr, flags))
120
 
    return 0;
121
 
 
122
 
  return ((new_field_ptr->sql_type == real_type()) &&
123
 
          new_field_ptr->charset == field_charset &&
124
 
          new_field_ptr->length == max_display_length());
125
 
}
126
 
 
127
155
 
128
156
bool check_string_copy_error(Field_str *field,
129
157
                             const char *well_formed_error_pos,
162
190
    {
163
191
      *t++= '\\';
164
192
      *t++= 'x';
165
 
      *t++= _dig_vec_upper[((unsigned char) *pos) >> 4];
166
 
      *t++= _dig_vec_upper[((unsigned char) *pos) & 15];
 
193
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) >> 4];
 
194
      *t++= internal::_dig_vec_upper[((unsigned char) *pos) & 15];
167
195
    }
168
196
  }
169
197
  if (end_orig > end)
184
212
  return true;
185
213
}
186
214
 
 
215
uint32_t Field_str::max_data_length() const
 
216
{
 
217
  return field_length + (field_length > 255 ? 2 : 1);
 
218
}
 
219
 
 
220
} /* namespace drizzled */