← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/fstring.cc

  • Committer: Monty Taylor
  • Date: 2008-11-16 20:15:33 UTC
  • mto: (584.1.9 devel)
  • mto: This revision was merged to the branch mainline in revision 589.
  • Revision ID: monty@inaugust.com-20081116201533-d0f19s1bk1h95iyw
Removed a big bank of includes from item.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/fstring.cc
 
1
/* - mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2008 MySQL
 
5
 *
 
6
 *  This program is free software; you can redistribute it and/or modify
 
7
 *  it under the terms of the GNU General Public License as published by
 
8
 *  the Free Software Foundation; either version 2 of the License, or
 
9
 *  (at your option) any later version.
 
10
 *
 
11
 *  This program is distributed in the hope that it will be useful,
 
12
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 *  GNU General Public License for more details.
 
15
 *
 
16
 *  You should have received a copy of the GNU General Public License
 
17
 *  along with this program; if not, write to the Free Software
 
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
 */
 
20
 
 
21
 
 
22
#include <drizzled/server_includes.h>
 
23
#include <drizzled/field/fstring.h>
 
24
#include <drizzled/error.h>
 
25
 
 
26
#define LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE 128
 
27
#define DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE 128
 
28
 
 
29
/****************************************************************************
 
30
** string type
 
31
** A string may be varchar or binary
 
32
****************************************************************************/
 
33
 
 
34
/* Copy a string and fill with space */
 
35
int Field_string::store(const char *from,uint32_t length, const CHARSET_INFO * const cs)
 
36
{
 
37
  uint32_t copy_length;
 
38
  const char *well_formed_error_pos;
 
39
  const char *cannot_convert_error_pos;
 
40
  const char *from_end_pos;
 
41
 
 
42
  /* See the comment for Field_long::store(int64_t) */
 
43
  assert(table->in_use == current_session);
 
44
 
 
45
  copy_length= well_formed_copy_nchars(field_charset,
 
46
                                       (char*) ptr, field_length,
 
47
                                       cs, from, length,
 
48
                                       field_length / field_charset->mbmaxlen,
 
49
                                       &well_formed_error_pos,
 
50
                                       &cannot_convert_error_pos,
 
51
                                       &from_end_pos);
 
52
 
 
53
  /* Append spaces if the string was shorter than the field. */
 
54
  if (copy_length < field_length)
 
55
    field_charset->cset->fill(field_charset,(char*) ptr+copy_length,
 
56
                              field_length-copy_length,
 
57
                              field_charset->pad_char);
 
58
 
 
59
  if (check_string_copy_error(this, well_formed_error_pos,
 
60
                              cannot_convert_error_pos, from + length, cs))
 
61
    return 2;
 
62
 
 
63
  return report_if_important_data(from_end_pos, from + length);
 
64
}
 
65
 
 
66
 
 
67
int Field_string::store(int64_t nr, bool unsigned_val)
 
68
{
 
69
  char buff[64];
 
70
  int  l;
 
71
  const CHARSET_INFO * const cs= charset();
 
72
  l= (cs->cset->int64_t10_to_str)(cs,buff,sizeof(buff),
 
73
                                   unsigned_val ? 10 : -10, nr);
 
74
  return Field_string::store(buff,(uint)l,cs);
 
75
}
 
76
 
 
77
 
 
78
double Field_string::val_real(void)
 
79
{
 
80
  int error;
 
81
  char *end;
 
82
  const CHARSET_INFO * const cs= charset();
 
83
  double result;
 
84
  
 
85
  result=  my_strntod(cs,(char*) ptr,field_length,&end,&error);
 
86
  if (!table->in_use->no_errors &&
 
87
      (error || (field_length != (uint32_t)(end - (char*) ptr) && 
 
88
                 !check_if_only_end_space(cs, end,
 
89
                                          (char*) ptr + field_length))))
 
90
  {
 
91
    char buf[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
 
92
    String tmp(buf, sizeof(buf), cs);
 
93
    tmp.copy((char*) ptr, field_length, cs);
 
94
    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
95
                        ER_TRUNCATED_WRONG_VALUE, 
 
96
                        ER(ER_TRUNCATED_WRONG_VALUE),
 
97
                        "DOUBLE", tmp.c_ptr());
 
98
  }
 
99
  return result;
 
100
}
 
101
 
 
102
 
 
103
int64_t Field_string::val_int(void)
 
104
{
 
105
  int error;
 
106
  char *end;
 
107
  const CHARSET_INFO * const cs= charset();
 
108
  int64_t result;
 
109
 
 
110
  result= my_strntoll(cs, (char*) ptr,field_length,10,&end,&error);
 
111
  if (!table->in_use->no_errors &&
 
112
      (error || (field_length != (uint32_t)(end - (char*) ptr) && 
 
113
                 !check_if_only_end_space(cs, end,
 
114
                                          (char*) ptr + field_length))))
 
115
  {
 
116
    char buf[LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE];
 
117
    String tmp(buf, sizeof(buf), cs);
 
118
    tmp.copy((char*) ptr, field_length, cs);
 
119
    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
120
                        ER_TRUNCATED_WRONG_VALUE, 
 
121
                        ER(ER_TRUNCATED_WRONG_VALUE),
 
122
                        "INTEGER", tmp.c_ptr());
 
123
  }
 
124
  return result;
 
125
}
 
126
 
 
127
 
 
128
String *Field_string::val_str(String *val_buffer __attribute__((unused)),
 
129
                              String *val_ptr)
 
130
{
 
131
  /* See the comment for Field_long::store(int64_t) */
 
132
  assert(table->in_use == current_session);
 
133
  uint32_t length;
 
134
 
 
135
  length= field_charset->cset->lengthsp(field_charset, (const char*) ptr, field_length);
 
136
  val_ptr->set((const char*) ptr, length, field_charset);
 
137
 
 
138
  return val_ptr;
 
139
}
 
140
 
 
141
 
 
142
my_decimal *Field_string::val_decimal(my_decimal *decimal_value)
 
143
{
 
144
  int err= str2my_decimal(E_DEC_FATAL_ERROR, (char*) ptr, field_length,
 
145
                          charset(), decimal_value);
 
146
  if (!table->in_use->no_errors && err)
 
147
  {
 
148
    char buf[DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE];
 
149
    const CHARSET_INFO * const cs= charset();
 
150
    String tmp(buf, sizeof(buf), cs);
 
151
    tmp.copy((char*) ptr, field_length, cs);
 
152
    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
153
                        ER_TRUNCATED_WRONG_VALUE, 
 
154
                        ER(ER_TRUNCATED_WRONG_VALUE),
 
155
                        "DECIMAL", tmp.c_ptr());
 
156
  }
 
157
 
 
158
  return decimal_value;
 
159
}
 
160
 
 
161
 
 
162
int Field_string::cmp(const unsigned char *a_ptr, const unsigned char *b_ptr)
 
163
{
 
164
  uint32_t a_len, b_len;
 
165
 
 
166
  if (field_charset->mbmaxlen != 1)
 
167
  {
 
168
    uint32_t char_len= field_length/field_charset->mbmaxlen;
 
169
    a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
 
170
    b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
 
171
  }
 
172
  else
 
173
    a_len= b_len= field_length;
 
174
  /*
 
175
    We have to remove end space to be able to compare multi-byte-characters
 
176
    like in latin_de 'ae' and 0xe4
 
177
  */
 
178
  return field_charset->coll->strnncollsp(field_charset,
 
179
                                          a_ptr, a_len,
 
180
                                          b_ptr, b_len,
 
181
                                          0);
 
182
}
 
183
 
 
184
 
 
185
void Field_string::sort_string(unsigned char *to,uint32_t length)
 
186
{
 
187
  uint32_t tmp= my_strnxfrm(field_charset,
 
188
                                 to, length,
 
189
                                 ptr, field_length);
 
190
  assert(tmp == length);
 
191
}
 
192
 
 
193
 
 
194
void Field_string::sql_type(String &res) const
 
195
{
 
196
  Session *session= table->in_use;
 
197
  const CHARSET_INFO * const cs= res.charset();
 
198
  uint32_t length;
 
199
 
 
200
  length= cs->cset->snprintf(cs,(char*) res.ptr(),
 
201
                             res.alloced_length(), "%s(%d)",
 
202
                             ((type() == DRIZZLE_TYPE_VARCHAR &&
 
203
                               !session->variables.new_mode) ?
 
204
                              (has_charset() ? "varchar" : "varbinary") :
 
205
                              (has_charset() ? "char" : "binary")),
 
206
                             (int) field_length / charset()->mbmaxlen);
 
207
  res.length(length);
 
208
}
 
209
 
 
210
 
 
211
unsigned char *Field_string::pack(unsigned char *to, const unsigned char *from,
 
212
                          uint32_t max_length,
 
213
                          bool low_byte_first __attribute__((unused)))
 
214
{
 
215
  uint32_t length=      cmin(field_length,max_length);
 
216
  uint32_t local_char_length= max_length/field_charset->mbmaxlen;
 
217
  if (length > local_char_length)
 
218
    local_char_length= my_charpos(field_charset, from, from+length,
 
219
                                  local_char_length);
 
220
  set_if_smaller(length, local_char_length);
 
221
  while (length && from[length-1] == field_charset->pad_char)
 
222
    length--;
 
223
 
 
224
  // Length always stored little-endian
 
225
  *to++= (unsigned char) length;
 
226
  if (field_length > 255)
 
227
    *to++= (unsigned char) (length >> 8);
 
228
 
 
229
  // Store the actual bytes of the string
 
230
  memcpy(to, from, length);
 
231
  return to+length;
 
232
}
 
233
 
 
234
 
 
235
/**
 
236
   Unpack a string field from row data.
 
237
 
 
238
   This method is used to unpack a string field from a master whose size 
 
239
   of the field is less than that of the slave. Note that there can be a
 
240
   variety of field types represented with this class. Certain types like
 
241
   ENUM or SET are processed differently. Hence, the upper byte of the 
 
242
   @c param_data argument contains the result of field->real_type() from
 
243
   the master.
 
244
 
 
245
   @param   to         Destination of the data
 
246
   @param   from       Source of the data
 
247
   @param   param_data Real type (upper) and length (lower) values
 
248
 
 
249
   @return  New pointer into memory based on from + length of the data
 
250
*/
 
251
const unsigned char *
 
252
Field_string::unpack(unsigned char *to,
 
253
                     const unsigned char *from,
 
254
                     uint32_t param_data,
 
255
                     bool low_byte_first __attribute__((unused)))
 
256
{
 
257
  uint32_t from_length=
 
258
    param_data ? cmin(param_data & 0x00ff, field_length) : field_length;
 
259
  uint32_t length;
 
260
 
 
261
  if (from_length > 255)
 
262
  {
 
263
    length= uint2korr(from);
 
264
    from+= 2;
 
265
  }
 
266
  else
 
267
    length= (uint) *from++;
 
268
 
 
269
  memcpy(to, from, length);
 
270
  // Pad the string with the pad character of the fields charset
 
271
  memset(to + length, field_charset->pad_char, field_length - length);
 
272
  return from+length;
 
273
}
 
274
 
 
275
 
 
276
/**
 
277
   Save the field metadata for string fields.
 
278
 
 
279
   Saves the real type in the first byte and the field length in the 
 
280
   second byte of the field metadata array at index of *metadata_ptr and
 
281
   *(metadata_ptr + 1).
 
282
 
 
283
   @param   metadata_ptr   First byte of field metadata
 
284
 
 
285
   @returns number of bytes written to metadata_ptr
 
286
*/
 
287
int Field_string::do_save_field_metadata(unsigned char *metadata_ptr)
 
288
{
 
289
  *metadata_ptr= real_type();
 
290
  *(metadata_ptr + 1)= field_length;
 
291
  return 2;
 
292
}
 
293
 
 
294
 
 
295
/*
 
296
  Compare two packed keys
 
297
 
 
298
  SYNOPSIS
 
299
    pack_cmp()
 
300
     a                  New key
 
301
     b                  Original key
 
302
     length             Key length
 
303
     insert_or_update   1 if this is an insert or update
 
304
 
 
305
  RETURN
 
306
    < 0   a < b
 
307
    0     a = b
 
308
    > 0   a > b
 
309
*/
 
310
 
 
311
int Field_string::pack_cmp(const unsigned char *a, const unsigned char *b, uint32_t length,
 
312
                           bool insert_or_update)
 
313
{
 
314
  uint32_t a_length, b_length;
 
315
  if (length > 255)
 
316
  {
 
317
    a_length= uint2korr(a);
 
318
    b_length= uint2korr(b);
 
319
    a+= 2;
 
320
    b+= 2;
 
321
  }
 
322
  else
 
323
  {
 
324
    a_length= (uint) *a++;
 
325
    b_length= (uint) *b++;
 
326
  }
 
327
  return field_charset->coll->strnncollsp(field_charset,
 
328
                                          a, a_length,
 
329
                                          b, b_length,
 
330
                                          insert_or_update);
 
331
}
 
332
 
 
333
 
 
334
/**
 
335
  Compare a packed key against row.
 
336
 
 
337
  @param key                    Original key
 
338
  @param length         Key length. (May be less than field length)
 
339
  @param insert_or_update       1 if this is an insert or update
 
340
 
 
341
  @return
 
342
    < 0   row < key
 
343
  @return
 
344
    0     row = key
 
345
  @return
 
346
    > 0   row > key
 
347
*/
 
348
 
 
349
int Field_string::pack_cmp(const unsigned char *key, uint32_t length,
 
350
                           bool insert_or_update)
 
351
{
 
352
  uint32_t row_length, local_key_length;
 
353
  unsigned char *end;
 
354
  if (length > 255)
 
355
  {
 
356
    local_key_length= uint2korr(key);
 
357
    key+= 2;
 
358
  }
 
359
  else
 
360
    local_key_length= (uint) *key++;
 
361
  
 
362
  /* Only use 'length' of key, not field_length */
 
363
  end= ptr + length;
 
364
  while (end > ptr && end[-1] == ' ')
 
365
    end--;
 
366
  row_length= (uint) (end - ptr);
 
367
 
 
368
  return field_charset->coll->strnncollsp(field_charset,
 
369
                                          ptr, row_length,
 
370
                                          key, local_key_length,
 
371
                                          insert_or_update);
 
372
}
 
373
 
 
374
 
 
375
uint32_t Field_string::packed_col_length(const unsigned char *data_ptr, uint32_t length)
 
376
{
 
377
  if (length > 255)
 
378
    return uint2korr(data_ptr)+2;
 
379
  return (uint) *data_ptr + 1;
 
380
}
 
381
 
 
382
 
 
383
uint32_t Field_string::max_packed_col_length(uint32_t max_length)
 
384
{
 
385
  return (max_length > 255 ? 2 : 1)+max_length;
 
386
}
 
387
 
 
388
 
 
389
uint32_t Field_string::get_key_image(unsigned char *buff,
 
390
                                 uint32_t length,
 
391
                                 imagetype type_arg __attribute__((unused)))
 
392
{
 
393
  uint32_t bytes = my_charpos(field_charset, (char*) ptr,
 
394
                          (char*) ptr + field_length,
 
395
                          length / field_charset->mbmaxlen);
 
396
  memcpy(buff, ptr, bytes);
 
397
  if (bytes < length)
 
398
    field_charset->cset->fill(field_charset, (char*) buff + bytes,
 
399
                              length - bytes, field_charset->pad_char);
 
400
  return bytes;
 
401
}
 
402
 
 
403
 
 
404
Field *Field_string::new_field(MEM_ROOT *root, Table *new_table, bool keep_type)
 
405
{
 
406
  Field *field;
 
407
  field= Field::new_field(root, new_table, keep_type);
 
408
  return field;
 
409
}
 
410
 
 
411