← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/varstring.cc

  • Committer: Mark Atwood
  • Date: 2010-06-24 03:15:21 UTC
  • mto: (1637.2.4 build)
  • mto: This revision was merged to the branch mainline in revision 1639.
  • Revision ID: me@mark.atwood.name-20100624031521-gafmppfbf5afm68w
new syslog module, with plugins for query log, error message, and SYSLOG() function

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/varstring.cc
19
19
 */
20
20
 
21
21
 
22
 
#include <config.h>
 
22
#include "config.h"
23
23
#include <drizzled/field/varstring.h>
24
24
#include <drizzled/table.h>
25
25
#include <drizzled/session.h>
26
 
#include <plugin/myisam/myisam.h>
 
26
#include "plugin/myisam/myisam.h"
27
27
 
28
28
#include <string>
29
29
 
56
56
                                 unsigned char *null_ptr_arg,
57
57
                                 unsigned char null_bit_arg,
58
58
                                 const char *field_name_arg,
59
 
                                 const CHARSET_INFO * const cs) :
60
 
  Field_str(ptr_arg,
61
 
            len_arg,
62
 
            null_ptr_arg,
63
 
            null_bit_arg,
64
 
            field_name_arg, cs),
65
 
length_bytes(length_bytes_arg)
 
59
                                 TableShare *share,
 
60
                                 const CHARSET_INFO * const cs)
 
61
  :Field_str(ptr_arg,
 
62
             len_arg,
 
63
             null_ptr_arg,
 
64
             null_bit_arg,
 
65
             field_name_arg, cs),
 
66
   length_bytes(length_bytes_arg)
66
67
{
 
68
  share->varchar_fields++;
67
69
}
68
70
 
69
71
Field_varstring::Field_varstring(uint32_t len_arg,
70
72
                                 bool maybe_null_arg,
71
73
                                 const char *field_name_arg,
72
 
                                 const CHARSET_INFO * const cs) :
73
 
  Field_str((unsigned char*) 0,
74
 
            len_arg,
75
 
            maybe_null_arg ? (unsigned char*) "": 0,
76
 
            0,
77
 
            field_name_arg,
78
 
            cs),
79
 
  length_bytes(len_arg < 256 ? 1 :2)
 
74
                                 TableShare *share,
 
75
                                 const CHARSET_INFO * const cs)
 
76
  :Field_str((unsigned char*) 0,
 
77
             len_arg,
 
78
             maybe_null_arg ? (unsigned char*) "": 0,
 
79
             0,
 
80
             field_name_arg,
 
81
             cs),
 
82
   length_bytes(len_arg < 256 ? 1 :2)
80
83
{
 
84
  share->varchar_fields++;
81
85
}
82
86
 
83
87
int Field_varstring::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
116
120
  char buff[64];
117
121
  uint32_t  length;
118
122
  length= (uint32_t) (field_charset->cset->int64_t10_to_str)(field_charset,
119
 
                                                             buff,
120
 
                                                             sizeof(buff),
121
 
                                                             (unsigned_val ? 10: -10),
122
 
                                                             nr);
 
123
                                                          buff,
 
124
                                                          sizeof(buff),
 
125
                                                          (unsigned_val ? 10:
 
126
                                                           -10),
 
127
                                                           nr);
123
128
  return Field_varstring::store(buff, length, field_charset);
124
129
}
125
130
 
126
131
 
127
 
double Field_varstring::val_real(void) const
 
132
double Field_varstring::val_real(void)
128
133
{
129
134
  int not_used;
130
135
  char *end_not_used;
138
143
}
139
144
 
140
145
 
141
 
int64_t Field_varstring::val_int(void) const
 
146
int64_t Field_varstring::val_int(void)
142
147
{
143
148
  int not_used;
144
149
  char *end_not_used;
152
157
                     &end_not_used, &not_used);
153
158
}
154
159
 
155
 
String *Field_varstring::val_str(String *, String *val_ptr) const
 
160
String *Field_varstring::val_str(String *,
 
161
                                 String *val_ptr)
156
162
{
157
163
  uint32_t length=  length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
158
164
 
164
170
}
165
171
 
166
172
 
167
 
type::Decimal *Field_varstring::val_decimal(type::Decimal *decimal_value) const
 
173
my_decimal *Field_varstring::val_decimal(my_decimal *decimal_value)
168
174
{
169
175
  uint32_t length;
170
176
 
172
178
 
173
179
  length= length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);
174
180
 
175
 
  decimal_value->store(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length, charset());
176
 
 
 
181
  str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr+length_bytes, length,
 
182
                 charset(), decimal_value);
177
183
  return decimal_value;
178
184
}
179
185
 
218
224
  uint32_t local_char_length= max_key_length / field_charset->mbmaxlen;
219
225
 
220
226
  local_char_length= my_charpos(field_charset, ptr + length_bytes,
221
 
                                ptr + length_bytes + length, local_char_length);
 
227
                          ptr + length_bytes + length, local_char_length);
222
228
  set_if_smaller(length, local_char_length);
223
229
  return field_charset->coll->strnncollsp(field_charset,
224
230
                                          ptr + length_bytes,
263
269
  }
264
270
 
265
271
  tot_length= my_strnxfrm(field_charset,
266
 
                          to, length, ptr + length_bytes,
267
 
                          tot_length);
 
272
                          to, length, ptr + length_bytes,
 
273
                          tot_length);
268
274
  assert(tot_length == length);
269
275
}
270
276