← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/fdecimal.cc

  • Committer: Brian Aker
  • Date: 2008-07-28 18:01:38 UTC
  • Revision ID: brian@tangent.org-20080728180138-q2pxlq0qiapvqsdn
Remove YEAR field type

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/fdecimal.cc
1
 
/* - mode: c++ c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2008 MySQL
18
18
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
19
19
 */
20
20
 
21
 
 
22
 
#include "config.h"
23
 
#include <drizzled/field/decimal.h>
24
 
#include <drizzled/error.h>
25
 
#include <drizzled/table.h>
26
 
#include <drizzled/session.h>
27
 
 
28
 
extern my_decimal decimal_zero;
 
21
#ifdef USE_PRAGMA_IMPLEMENTATION
 
22
#pragma implementation                          // gcc: Class implementation
 
23
#endif
 
24
 
 
25
#include <drizzled/field/fdecimal.h>
29
26
 
30
27
/****************************************************************************
31
 
 ** File_decimal
32
 
 ****************************************************************************/
33
 
 
34
 
Field_decimal::Field_decimal(unsigned char *ptr_arg,
35
 
                             uint32_t len_arg,
36
 
                             unsigned char *null_ptr_arg,
37
 
                             unsigned char null_bit_arg,
38
 
                             enum utype unireg_check_arg,
39
 
                             const char *field_name_arg,
40
 
                             uint8_t dec_arg,
41
 
                             bool zero_arg,
42
 
                             bool unsigned_arg)
43
 
:Field_num(ptr_arg,
44
 
           len_arg,
45
 
           null_ptr_arg,
46
 
           null_bit_arg,
47
 
           unireg_check_arg,
48
 
           field_name_arg,
49
 
           dec_arg, zero_arg,
50
 
           unsigned_arg)
51
 
{
52
 
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
53
 
  set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
54
 
  assert((precision <= DECIMAL_MAX_PRECISION) &&
55
 
         (dec <= DECIMAL_MAX_SCALE));
56
 
  bin_size= my_decimal_get_binary_size(precision, dec);
57
 
}
58
 
 
59
 
Field_decimal::Field_decimal(uint32_t len_arg,
60
 
                             bool maybe_null_arg,
61
 
                             const char *name,
62
 
                             uint8_t dec_arg,
63
 
                             bool unsigned_arg)
64
 
:Field_num((unsigned char*) 0,
65
 
           len_arg,
66
 
           maybe_null_arg ? (unsigned char*) "": 0,
67
 
           0,
68
 
           NONE,
69
 
           name,
70
 
           dec_arg,
71
 
           0,
72
 
           unsigned_arg)
73
 
{
74
 
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
75
 
  set_if_smaller(precision, (uint32_t)DECIMAL_MAX_PRECISION);
76
 
  assert((precision <= DECIMAL_MAX_PRECISION) &&
77
 
         (dec <= DECIMAL_MAX_SCALE));
78
 
  bin_size= my_decimal_get_binary_size(precision, dec);
79
 
}
80
 
 
81
 
 
82
 
int Field_decimal::reset(void)
 
28
** Field_new_decimal
 
29
****************************************************************************/
 
30
 
 
31
Field_new_decimal::Field_new_decimal(uchar *ptr_arg,
 
32
                                     uint32_t len_arg, uchar *null_ptr_arg,
 
33
                                     uchar null_bit_arg,
 
34
                                     enum utype unireg_check_arg,
 
35
                                     const char *field_name_arg,
 
36
                                     uint8_t dec_arg,bool zero_arg,
 
37
                                     bool unsigned_arg)
 
38
  :Field_num(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
 
39
             unireg_check_arg, field_name_arg, dec_arg, zero_arg, unsigned_arg)
 
40
{
 
41
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
 
42
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
 
43
  assert((precision <= DECIMAL_MAX_PRECISION) &&
 
44
              (dec <= DECIMAL_MAX_SCALE));
 
45
  bin_size= my_decimal_get_binary_size(precision, dec);
 
46
}
 
47
 
 
48
 
 
49
Field_new_decimal::Field_new_decimal(uint32_t len_arg,
 
50
                                     bool maybe_null_arg,
 
51
                                     const char *name,
 
52
                                     uint8_t dec_arg,
 
53
                                     bool unsigned_arg)
 
54
  :Field_num((uchar*) 0, len_arg,
 
55
             maybe_null_arg ? (uchar*) "": 0, 0,
 
56
             NONE, name, dec_arg, 0, unsigned_arg)
 
57
{
 
58
  precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
 
59
  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
 
60
  assert((precision <= DECIMAL_MAX_PRECISION) &&
 
61
              (dec <= DECIMAL_MAX_SCALE));
 
62
  bin_size= my_decimal_get_binary_size(precision, dec);
 
63
}
 
64
 
 
65
 
 
66
int Field_new_decimal::reset(void)
83
67
{
84
68
  store_value(&decimal_zero);
85
69
  return 0;
93
77
  @param sign              sign of value which caused overflow
94
78
*/
95
79
 
96
 
void Field_decimal::set_value_on_overflow(my_decimal *decimal_value,
97
 
                                          bool sign)
 
80
void Field_new_decimal::set_value_on_overflow(my_decimal *decimal_value,
 
81
                                              bool sign)
98
82
{
99
83
  max_my_decimal(decimal_value, precision, decimals());
100
84
  if (sign)
101
 
    decimal_value->sign(true);
102
 
 
 
85
  {
 
86
    if (unsigned_flag)
 
87
      my_decimal_set_zero(decimal_value);
 
88
    else
 
89
      decimal_value->sign(true);
 
90
  }
103
91
  return;
104
92
}
105
93
 
114
102
  @param decimal_value   my_decimal
115
103
 
116
104
  @retval
117
 
  0 ok
 
105
    0 ok
118
106
  @retval
119
 
  1 error
 
107
    1 error
120
108
*/
121
109
 
122
 
bool Field_decimal::store_value(const my_decimal *decimal_value)
 
110
bool Field_new_decimal::store_value(const my_decimal *decimal_value)
123
111
{
124
112
  int error= 0;
125
113
 
 
114
  /* check that we do not try to write negative value in unsigned field */
 
115
  if (unsigned_flag && decimal_value->sign())
 
116
  {
 
117
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
118
    error= 1;
 
119
    decimal_value= &decimal_zero;
 
120
  }
 
121
 
126
122
  if (warn_if_overflow(my_decimal2binary(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
127
123
                                         decimal_value, ptr, precision, dec)))
128
124
  {
135
131
}
136
132
 
137
133
 
138
 
int Field_decimal::store(const char *from, uint32_t length,
139
 
                         const CHARSET_INFO * const charset_arg)
 
134
int Field_new_decimal::store(const char *from, uint length,
 
135
                             CHARSET_INFO *charset_arg)
140
136
{
141
137
  int err;
142
138
  my_decimal decimal_value;
143
139
 
144
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
145
 
 
146
140
  if ((err= str2my_decimal(E_DEC_FATAL_ERROR &
147
141
                           ~(E_DEC_OVERFLOW | E_DEC_BAD_NUM),
148
142
                           from, length, charset_arg,
153
147
    String from_as_str;
154
148
    from_as_str.copy(from, length, &my_charset_bin);
155
149
 
156
 
    push_warning_printf(table->in_use, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
150
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_ERROR,
157
151
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
158
152
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
159
153
                        "decimal", from_as_str.c_ptr(), field_name,
160
 
                        (uint32_t) table->in_use->row_count);
 
154
                        (ulong) table->in_use->row_count);
161
155
 
162
156
    return(err);
163
157
  }
164
158
 
165
159
  switch (err) {
166
160
  case E_DEC_TRUNCATED:
167
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
168
 
    set_value_on_overflow(&decimal_value, decimal_value.sign());
 
161
    set_warning(MYSQL_ERROR::WARN_LEVEL_NOTE, WARN_DATA_TRUNCATED, 1);
169
162
    break;
170
163
  case E_DEC_OVERFLOW:
171
 
    set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
 
164
    set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
172
165
    set_value_on_overflow(&decimal_value, decimal_value.sign());
173
166
    break;
174
167
  case E_DEC_BAD_NUM:
177
170
      String from_as_str;
178
171
      from_as_str.copy(from, length, &my_charset_bin);
179
172
 
180
 
      push_warning_printf(table->in_use, DRIZZLE_ERROR::WARN_LEVEL_WARN,
181
 
                          ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
182
 
                          ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
 
173
    push_warning_printf(table->in_use, MYSQL_ERROR::WARN_LEVEL_WARN,
 
174
                        ER_TRUNCATED_WRONG_VALUE_FOR_FIELD,
 
175
                        ER(ER_TRUNCATED_WRONG_VALUE_FOR_FIELD),
183
176
                          "decimal", from_as_str.c_ptr(), field_name,
184
 
                          (uint32_t) table->in_use->row_count);
185
 
      my_decimal_set_zero(&decimal_value);
 
177
                        (ulong) table->in_use->row_count);
 
178
    my_decimal_set_zero(&decimal_value);
186
179
 
187
 
      break;
 
180
    break;
188
181
    }
189
182
  }
190
183
 
199
192
  will return E_DEC_TRUNCATED always correctly
200
193
*/
201
194
 
202
 
int Field_decimal::store(double nr)
 
195
int Field_new_decimal::store(double nr)
203
196
{
204
197
  my_decimal decimal_value;
205
198
  int err;
206
199
 
207
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
208
 
 
209
200
  err= double2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW, nr,
210
201
                         &decimal_value);
211
202
  if (err)
223
214
}
224
215
 
225
216
 
226
 
int Field_decimal::store(int64_t nr, bool unsigned_val)
 
217
int Field_new_decimal::store(int64_t nr, bool unsigned_val)
227
218
{
228
219
  my_decimal decimal_value;
229
220
  int err;
230
221
 
231
 
  ASSERT_COLUMN_MARKED_FOR_WRITE;
232
 
 
233
222
  if ((err= int2my_decimal(E_DEC_FATAL_ERROR & ~E_DEC_OVERFLOW,
234
223
                           nr, unsigned_val, &decimal_value)))
235
224
  {
246
235
}
247
236
 
248
237
 
249
 
int Field_decimal::store_decimal(const my_decimal *decimal_value)
 
238
int Field_new_decimal::store_decimal(const my_decimal *decimal_value)
250
239
{
251
240
  return store_value(decimal_value);
252
241
}
253
242
 
254
243
 
255
 
int Field_decimal::store_time(DRIZZLE_TIME *ltime,
256
 
                              enum enum_drizzle_timestamp_type )
 
244
int Field_new_decimal::store_time(MYSQL_TIME *ltime,
 
245
                                  timestamp_type t_type __attribute__((unused)))
257
246
{
258
 
  my_decimal decimal_value;
259
 
  return store_value(date2my_decimal(ltime, &decimal_value));
 
247
    my_decimal decimal_value;
 
248
    return store_value(date2my_decimal(ltime, &decimal_value));
260
249
}
261
250
 
262
251
 
263
 
double Field_decimal::val_real(void)
 
252
double Field_new_decimal::val_real(void)
264
253
{
265
254
  double dbl;
266
255
  my_decimal decimal_value;
267
 
 
268
 
  ASSERT_COLUMN_MARKED_FOR_READ;
269
 
 
270
256
  my_decimal2double(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), &dbl);
271
 
 
272
257
  return dbl;
273
258
}
274
259
 
275
260
 
276
 
int64_t Field_decimal::val_int(void)
 
261
int64_t Field_new_decimal::val_int(void)
277
262
{
278
263
  int64_t i;
279
264
  my_decimal decimal_value;
280
 
 
281
 
  ASSERT_COLUMN_MARKED_FOR_READ;
282
 
 
283
 
  my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value), false, &i);
284
 
 
 
265
  my_decimal2int(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
 
266
                 unsigned_flag, &i);
285
267
  return i;
286
268
}
287
269
 
288
270
 
289
 
my_decimal* Field_decimal::val_decimal(my_decimal *decimal_value)
 
271
my_decimal* Field_new_decimal::val_decimal(my_decimal *decimal_value)
290
272
{
291
 
  ASSERT_COLUMN_MARKED_FOR_READ;
292
 
 
293
273
  binary2my_decimal(E_DEC_FATAL_ERROR, ptr, decimal_value,
294
274
                    precision, dec);
295
275
  return(decimal_value);
296
276
}
297
277
 
298
278
 
299
 
String *Field_decimal::val_str(String *val_buffer,
300
 
                               String *)
 
279
String *Field_new_decimal::val_str(String *val_buffer,
 
280
                                   String *val_ptr __attribute__((unused)))
301
281
{
302
282
  my_decimal decimal_value;
303
 
 
304
 
  ASSERT_COLUMN_MARKED_FOR_READ;
305
 
 
306
 
  uint32_t fixed_precision= decimal_precision ? precision : 0;
 
283
  uint fixed_precision= decimal_precision ? precision : 0;
307
284
  my_decimal2string(E_DEC_FATAL_ERROR, val_decimal(&decimal_value),
308
285
                    fixed_precision, dec, '0', val_buffer);
309
286
  return val_buffer;
310
287
}
311
288
 
312
289
 
313
 
int Field_decimal::cmp(const unsigned char *a,const unsigned char*b)
 
290
int Field_new_decimal::cmp(const uchar *a,const uchar*b)
314
291
{
315
292
  return memcmp(a, b, bin_size);
316
293
}
317
294
 
318
295
 
319
 
void Field_decimal::sort_string(unsigned char *buff,
320
 
                                uint32_t )
 
296
void Field_new_decimal::sort_string(uchar *buff,
 
297
                                    uint length __attribute__((unused)))
321
298
{
322
299
  memcpy(buff, ptr, bin_size);
323
300
}
324
301
 
325
302
 
326
 
void Field_decimal::sql_type(String &str) const
 
303
void Field_new_decimal::sql_type(String &str) const
327
304
{
328
 
  const CHARSET_INFO * const cs= str.charset();
 
305
  CHARSET_INFO *cs= str.charset();
329
306
  str.length(cs->cset->snprintf(cs, (char*) str.ptr(), str.alloced_length(),
330
307
                                "decimal(%d,%d)", precision, (int)dec));
331
 
}
332
 
 
333
 
 
334
 
/**
335
 
  Returns the number of bytes field uses in row-based replication
336
 
  row packed size.
337
 
 
338
 
  This method is used in row-based replication to determine the number
339
 
  of bytes that the field consumes in the row record format. This is
340
 
  used to skip fields in the master that do not exist on the slave.
341
 
 
342
 
  @param   field_metadata   Encoded size in field metadata
343
 
 
344
 
  @returns The size of the field based on the field metadata.
345
 
*/
346
 
uint32_t Field_decimal::pack_length_from_metadata(uint32_t field_metadata)
347
 
{
348
 
  uint32_t const source_precision= (field_metadata >> 8U) & 0x00ff;
349
 
  uint32_t const source_decimal= field_metadata & 0x00ff;
350
 
  uint32_t const source_size= my_decimal_get_binary_size(source_precision,
351
 
                                                         source_decimal);
 
308
  add_unsigned(str);
 
309
}
 
310
 
 
311
 
 
312
/**
 
313
   Save the field metadata for new decimal fields.
 
314
 
 
315
   Saves the precision in the first byte and decimals() in the second
 
316
   byte of the field metadata array at index of *metadata_ptr and 
 
317
   *(metadata_ptr + 1).
 
318
 
 
319
   @param   metadata_ptr   First byte of field metadata
 
320
 
 
321
   @returns number of bytes written to metadata_ptr
 
322
*/
 
323
int Field_new_decimal::do_save_field_metadata(uchar *metadata_ptr)
 
324
{
 
325
  *metadata_ptr= precision;
 
326
  *(metadata_ptr + 1)= decimals();
 
327
  return 2;
 
328
}
 
329
 
 
330
 
 
331
/**
 
332
   Returns the number of bytes field uses in row-based replication 
 
333
   row packed size.
 
334
 
 
335
   This method is used in row-based replication to determine the number
 
336
   of bytes that the field consumes in the row record format. This is
 
337
   used to skip fields in the master that do not exist on the slave.
 
338
 
 
339
   @param   field_metadata   Encoded size in field metadata
 
340
 
 
341
   @returns The size of the field based on the field metadata.
 
342
*/
 
343
uint Field_new_decimal::pack_length_from_metadata(uint field_metadata)
 
344
{
 
345
  uint const source_precision= (field_metadata >> 8U) & 0x00ff;
 
346
  uint const source_decimal= field_metadata & 0x00ff; 
 
347
  uint const source_size= my_decimal_get_binary_size(source_precision, 
 
348
                                                     source_decimal);
352
349
  return (source_size);
353
350
}
354
351
 
355
352
 
356
353
/**
357
 
  Check to see if field size is compatible with destination.
358
 
 
359
 
  This method is used in row-based replication to verify that the slave's
360
 
  field size is less than or equal to the master's field size. The
361
 
  encoded field metadata (from the master or source) is decoded and compared
362
 
  to the size of this field (the slave or destination).
363
 
 
364
 
  @param   field_metadata   Encoded size in field metadata
365
 
 
366
 
  @retval 0 if this field's size is < the source field's size
367
 
  @retval 1 if this field's size is >= the source field's size
 
354
   Check to see if field size is compatible with destination.
 
355
 
 
356
   This method is used in row-based replication to verify that the slave's
 
357
   field size is less than or equal to the master's field size. The 
 
358
   encoded field metadata (from the master or source) is decoded and compared
 
359
   to the size of this field (the slave or destination). 
 
360
 
 
361
   @param   field_metadata   Encoded size in field metadata
 
362
 
 
363
   @retval 0 if this field's size is < the source field's size
 
364
   @retval 1 if this field's size is >= the source field's size
368
365
*/
369
 
int Field_decimal::compatible_field_size(uint32_t field_metadata)
 
366
int Field_new_decimal::compatible_field_size(uint field_metadata)
370
367
{
371
368
  int compatible= 0;
372
 
  uint32_t const source_precision= (field_metadata >> 8U) & 0x00ff;
373
 
  uint32_t const source_decimal= field_metadata & 0x00ff;
374
 
  uint32_t const source_size= my_decimal_get_binary_size(source_precision,
375
 
                                                         source_decimal);
376
 
  uint32_t const destination_size= row_pack_length();
 
369
  uint const source_precision= (field_metadata >> 8U) & 0x00ff;
 
370
  uint const source_decimal= field_metadata & 0x00ff; 
 
371
  uint const source_size= my_decimal_get_binary_size(source_precision, 
 
372
                                                     source_decimal);
 
373
  uint const destination_size= row_pack_length();
377
374
  compatible= (source_size <= destination_size);
378
375
  if (compatible)
379
376
    compatible= (source_precision <= precision) &&
380
 
      (source_decimal <= decimals());
 
377
                (source_decimal <= decimals());
381
378
  return (compatible);
382
379
}
383
380
 
384
381
 
385
 
uint32_t Field_decimal::is_equal(CreateField *new_field_ptr)
 
382
uint Field_new_decimal::is_equal(Create_field *new_field)
386
383
{
387
 
  return ((new_field_ptr->sql_type == real_type()) &&
388
 
          ((new_field_ptr->flags & UNSIGNED_FLAG) ==
389
 
           (uint32_t) (flags & UNSIGNED_FLAG)) &&
390
 
          ((new_field_ptr->flags & AUTO_INCREMENT_FLAG) ==
391
 
           (uint32_t) (flags & AUTO_INCREMENT_FLAG)) &&
392
 
          (new_field_ptr->length == max_display_length()) &&
393
 
          (new_field_ptr->decimals == dec));
 
384
  return ((new_field->sql_type == real_type()) &&
 
385
          ((new_field->flags & UNSIGNED_FLAG) == 
 
386
           (uint) (flags & UNSIGNED_FLAG)) &&
 
387
          ((new_field->flags & AUTO_INCREMENT_FLAG) ==
 
388
           (uint) (flags & AUTO_INCREMENT_FLAG)) &&
 
389
          (new_field->length == max_display_length()) &&
 
390
          (new_field->decimals == dec));
394
391
}
395
392
 
396
393
 
397
394
/**
398
 
  Unpack a decimal field from row data.
399
 
 
400
 
  This method is used to unpack a decimal or numeric field from a master
401
 
  whose size of the field is less than that of the slave.
402
 
 
403
 
  @param   to         Destination of the data
404
 
  @param   from       Source of the data
405
 
  @param   param_data Precision (upper) and decimal (lower) values
406
 
 
407
 
  @return  New pointer into memory based on from + length of the data
 
395
   Unpack a decimal field from row data.
 
396
 
 
397
   This method is used to unpack a decimal or numeric field from a master
 
398
   whose size of the field is less than that of the slave.
 
399
  
 
400
   @param   to         Destination of the data
 
401
   @param   from       Source of the data
 
402
   @param   param_data Precision (upper) and decimal (lower) values
 
403
 
 
404
   @return  New pointer into memory based on from + length of the data
408
405
*/
409
 
const unsigned char *
410
 
Field_decimal::unpack(unsigned char* to,
411
 
                      const unsigned char *from,
412
 
                      uint32_t param_data,
413
 
                      bool low_byte_first)
 
406
const uchar *
 
407
Field_new_decimal::unpack(uchar* to,
 
408
                          const uchar *from,
 
409
                          uint param_data,
 
410
                          bool low_byte_first)
414
411
{
415
412
  if (param_data == 0)
416
413
    return Field::unpack(to, from, param_data, low_byte_first);
417
414
 
418
 
  uint32_t from_precision= (param_data & 0xff00) >> 8U;
419
 
  uint32_t from_decimal= param_data & 0x00ff;
420
 
  uint32_t length=pack_length();
421
 
  uint32_t from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal);
422
 
  uint32_t len= (param_data && (from_pack_len < length)) ?
423
 
    from_pack_len : length;
 
415
  uint from_precision= (param_data & 0xff00) >> 8U;
 
416
  uint from_decimal= param_data & 0x00ff;
 
417
  uint length=pack_length();
 
418
  uint from_pack_len= my_decimal_get_binary_size(from_precision, from_decimal);
 
419
  uint len= (param_data && (from_pack_len < length)) ?
 
420
            from_pack_len : length;
424
421
  if ((from_pack_len && (from_pack_len < length)) ||
425
422
      (from_precision < precision) ||
426
423
      (from_decimal < decimals()))
431
428
      a decimal and write that to the raw data buffer.
432
429
    */
433
430
    decimal_digit_t dec_buf[DECIMAL_MAX_PRECISION];
434
 
    decimal_t conv_dec;
435
 
    conv_dec.len= from_precision;
436
 
    conv_dec.buf= dec_buf;
 
431
    decimal_t dec;
 
432
    dec.len= from_precision;
 
433
    dec.buf= dec_buf;
437
434
    /*
438
 
Note: bin2decimal does not change the length of the field. So it is
439
 
just the first step the resizing operation. The second step does the
440
 
resizing using the precision and decimals from the slave.
 
435
      Note: bin2decimal does not change the length of the field. So it is
 
436
      just the first step the resizing operation. The second step does the
 
437
      resizing using the precision and decimals from the slave.
441
438
    */
442
 
    bin2decimal((unsigned char *)from, &conv_dec, from_precision, from_decimal);
443
 
    decimal2bin(&conv_dec, to, precision, decimals());
 
439
    bin2decimal((uchar *)from, &dec, from_precision, from_decimal);
 
440
    decimal2bin(&dec, to, precision, decimals());
444
441
  }
445
442
  else
446
443
    memcpy(to, from, len); // Sizes are the same, just copy the data.