← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field_conv.cc

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field_conv.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
14
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
15
 
16
16
 
17
17
/**
24
24
    gives much more speed.
25
25
*/
26
26
 
27
 
#include <drizzled/server_includes.h>
28
 
 
29
 
static void do_field_eq(Copy_field *copy)
30
 
{
31
 
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
32
 
}
33
 
 
34
 
static void do_field_1(Copy_field *copy)
35
 
{
36
 
  copy->to_ptr[0]=copy->from_ptr[0];
37
 
}
38
 
 
39
 
static void do_field_2(Copy_field *copy)
40
 
{
41
 
  copy->to_ptr[0]=copy->from_ptr[0];
42
 
  copy->to_ptr[1]=copy->from_ptr[1];
43
 
}
44
 
 
45
 
static void do_field_3(Copy_field *copy)
46
 
{
47
 
  copy->to_ptr[0]=copy->from_ptr[0];
48
 
  copy->to_ptr[1]=copy->from_ptr[1];
49
 
  copy->to_ptr[2]=copy->from_ptr[2];
50
 
}
51
 
 
52
 
static void do_field_4(Copy_field *copy)
53
 
{
54
 
  copy->to_ptr[0]=copy->from_ptr[0];
55
 
  copy->to_ptr[1]=copy->from_ptr[1];
56
 
  copy->to_ptr[2]=copy->from_ptr[2];
57
 
  copy->to_ptr[3]=copy->from_ptr[3];
58
 
}
59
 
 
60
 
static void do_field_6(Copy_field *copy)
61
 
{                                               // For blob field
62
 
  copy->to_ptr[0]=copy->from_ptr[0];
63
 
  copy->to_ptr[1]=copy->from_ptr[1];
64
 
  copy->to_ptr[2]=copy->from_ptr[2];
65
 
  copy->to_ptr[3]=copy->from_ptr[3];
66
 
  copy->to_ptr[4]=copy->from_ptr[4];
67
 
  copy->to_ptr[5]=copy->from_ptr[5];
68
 
}
69
 
 
70
 
static void do_field_8(Copy_field *copy)
71
 
{
72
 
  copy->to_ptr[0]=copy->from_ptr[0];
73
 
  copy->to_ptr[1]=copy->from_ptr[1];
74
 
  copy->to_ptr[2]=copy->from_ptr[2];
75
 
  copy->to_ptr[3]=copy->from_ptr[3];
76
 
  copy->to_ptr[4]=copy->from_ptr[4];
77
 
  copy->to_ptr[5]=copy->from_ptr[5];
78
 
  copy->to_ptr[6]=copy->from_ptr[6];
79
 
  copy->to_ptr[7]=copy->from_ptr[7];
80
 
}
81
 
 
82
 
 
83
 
static void do_field_to_null_str(Copy_field *copy)
 
27
#include "config.h"
 
28
#include <drizzled/error.h>
 
29
#include <drizzled/table.h>
 
30
#include <drizzled/session.h>
 
31
 
 
32
#include <drizzled/field/str.h>
 
33
#include <drizzled/field/num.h>
 
34
#include <drizzled/field/blob.h>
 
35
#include <drizzled/field/enum.h>
 
36
#include <drizzled/field/null.h>
 
37
#include <drizzled/field/date.h>
 
38
#include <drizzled/field/decimal.h>
 
39
#include <drizzled/field/real.h>
 
40
#include <drizzled/field/double.h>
 
41
#include <drizzled/field/int32.h>
 
42
#include <drizzled/field/int64.h>
 
43
#include <drizzled/field/num.h>
 
44
#include <drizzled/field/timestamp.h>
 
45
#include <drizzled/field/datetime.h>
 
46
#include <drizzled/field/varstring.h>
 
47
 
 
48
namespace drizzled
 
49
{
 
50
 
 
51
static void do_field_eq(CopyField *copy)
 
52
{
 
53
  memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
 
54
}
 
55
 
 
56
static void do_field_1(CopyField *copy)
 
57
{
 
58
  copy->to_ptr[0]= copy->from_ptr[0];
 
59
}
 
60
 
 
61
static void do_field_2(CopyField *copy)
 
62
{
 
63
  copy->to_ptr[0]= copy->from_ptr[0];
 
64
  copy->to_ptr[1]= copy->from_ptr[1];
 
65
}
 
66
 
 
67
static void do_field_3(CopyField *copy)
 
68
{
 
69
  copy->to_ptr[0]= copy->from_ptr[0];
 
70
  copy->to_ptr[1]= copy->from_ptr[1];
 
71
  copy->to_ptr[2]= copy->from_ptr[2];
 
72
}
 
73
 
 
74
static void do_field_4(CopyField *copy)
 
75
{
 
76
  copy->to_ptr[0]= copy->from_ptr[0];
 
77
  copy->to_ptr[1]= copy->from_ptr[1];
 
78
  copy->to_ptr[2]= copy->from_ptr[2];
 
79
  copy->to_ptr[3]= copy->from_ptr[3];
 
80
}
 
81
 
 
82
static void do_field_6(CopyField *copy)
 
83
{                  // For blob field
 
84
  copy->to_ptr[0]= copy->from_ptr[0];
 
85
  copy->to_ptr[1]= copy->from_ptr[1];
 
86
  copy->to_ptr[2]= copy->from_ptr[2];
 
87
  copy->to_ptr[3]= copy->from_ptr[3];
 
88
  copy->to_ptr[4]= copy->from_ptr[4];
 
89
  copy->to_ptr[5]= copy->from_ptr[5];
 
90
}
 
91
 
 
92
static void do_field_8(CopyField *copy)
 
93
{
 
94
  copy->to_ptr[0]= copy->from_ptr[0];
 
95
  copy->to_ptr[1]= copy->from_ptr[1];
 
96
  copy->to_ptr[2]= copy->from_ptr[2];
 
97
  copy->to_ptr[3]= copy->from_ptr[3];
 
98
  copy->to_ptr[4]= copy->from_ptr[4];
 
99
  copy->to_ptr[5]= copy->from_ptr[5];
 
100
  copy->to_ptr[6]= copy->from_ptr[6];
 
101
  copy->to_ptr[7]= copy->from_ptr[7];
 
102
}
 
103
 
 
104
 
 
105
static void do_field_to_null_str(CopyField *copy)
84
106
{
85
107
  if (*copy->from_null_ptr & copy->from_bit)
86
108
  {
87
109
    memset(copy->to_ptr, 0, copy->from_length);
88
 
    copy->to_null_ptr[0]=1;                     // Always bit 1
 
110
    copy->to_null_ptr[0]= 1;  // Always bit 1
89
111
  }
90
112
  else
91
113
  {
92
 
    copy->to_null_ptr[0]=0;
93
 
    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
114
    copy->to_null_ptr[0]= 0;
 
115
    memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
94
116
  }
95
117
}
96
118
 
97
119
 
98
 
static void do_outer_field_to_null_str(Copy_field *copy)
 
120
static void do_outer_field_to_null_str(CopyField *copy)
99
121
{
100
122
  if (*copy->null_row ||
101
123
      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
102
124
  {
103
125
    memset(copy->to_ptr, 0, copy->from_length);
104
 
    copy->to_null_ptr[0]=1;                     // Always bit 1
 
126
    copy->to_null_ptr[0]= 1;  // Always bit 1
105
127
  }
106
128
  else
107
129
  {
108
 
    copy->to_null_ptr[0]=0;
109
 
    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
130
    copy->to_null_ptr[0]= 0;
 
131
    memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
110
132
  }
111
133
}
112
134
 
121
143
    return 0;
122
144
  }
123
145
  field->reset();
124
 
  if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN)
 
146
  if (field->getTable()->in_use->count_cuted_fields == CHECK_FIELD_WARN)
125
147
  {
126
148
    field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
127
149
    return 0;
128
150
  }
129
 
  if (!field->table->in_use->no_errors)
 
151
  if (!field->getTable()->in_use->no_errors)
130
152
    my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
131
153
  return -1;
132
154
}
172
194
    return 0;                                   // Ok to set time to NULL
173
195
  }
174
196
  field->reset();
175
 
  if (field == field->table->next_number_field)
 
197
  if (field == field->getTable()->next_number_field)
176
198
  {
177
 
    field->table->auto_increment_field_not_null= false;
 
199
    field->getTable()->auto_increment_field_not_null= false;
178
200
    return 0;                             // field is set in fill_record()
179
201
  }
180
 
  if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN)
 
202
  if (field->getTable()->in_use->count_cuted_fields == CHECK_FIELD_WARN)
181
203
  {
182
204
    field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_BAD_NULL_ERROR, 1);
183
205
    return 0;
184
206
  }
185
 
  if (!field->table->in_use->no_errors)
 
207
  if (!field->getTable()->in_use->no_errors)
186
208
    my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
187
209
  return -1;
188
210
}
189
211
 
190
212
 
191
 
static void do_skip(Copy_field *copy __attribute__((unused)))
 
213
static void do_skip(CopyField *)
192
214
{
193
215
}
194
216
 
195
217
 
196
 
static void do_copy_null(Copy_field *copy)
 
218
static void do_copy_null(CopyField *copy)
197
219
{
198
220
  if (*copy->from_null_ptr & copy->from_bit)
199
221
  {
200
 
    *copy->to_null_ptr|=copy->to_bit;
 
222
    *copy->to_null_ptr|= copy->to_bit;
201
223
    copy->to_field->reset();
202
224
  }
203
225
  else
208
230
}
209
231
 
210
232
 
211
 
static void do_outer_field_null(Copy_field *copy)
 
233
static void do_outer_field_null(CopyField *copy)
212
234
{
213
235
  if (*copy->null_row ||
214
236
      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
224
246
}
225
247
 
226
248
 
227
 
static void do_copy_not_null(Copy_field *copy)
 
249
static void do_copy_not_null(CopyField *copy)
228
250
{
229
 
  if (*copy->from_null_ptr & copy->from_bit)
 
251
  if (copy->to_field->hasDefault() and *copy->from_null_ptr & copy->from_bit)
 
252
  {
 
253
    copy->to_field->set_default();
 
254
  }
 
255
  else if (*copy->from_null_ptr & copy->from_bit)
230
256
  {
231
257
    copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
232
258
                                ER_WARN_DATA_TRUNCATED, 1);
233
259
    copy->to_field->reset();
234
260
  }
235
261
  else
 
262
  {
236
263
    (copy->do_copy2)(copy);
 
264
  }
237
265
}
238
266
 
239
267
 
240
 
static void do_copy_maybe_null(Copy_field *copy)
 
268
static void do_copy_maybe_null(CopyField *copy)
241
269
{
242
270
  *copy->to_null_ptr&= ~copy->to_bit;
243
271
  (copy->do_copy2)(copy);
245
273
 
246
274
/* timestamp and next_number has special handling in case of NULL values */
247
275
 
248
 
static void do_copy_timestamp(Copy_field *copy)
 
276
static void do_copy_timestamp(CopyField *copy)
249
277
{
250
278
  if (*copy->from_null_ptr & copy->from_bit)
251
279
  {
257
285
}
258
286
 
259
287
 
260
 
static void do_copy_next_number(Copy_field *copy)
 
288
static void do_copy_next_number(CopyField *copy)
261
289
{
262
290
  if (*copy->from_null_ptr & copy->from_bit)
263
291
  {
264
292
    /* Same as in set_field_to_null_with_conversions() */
265
 
    copy->to_field->table->auto_increment_field_not_null= false;
 
293
    copy->to_field->getTable()->auto_increment_field_not_null= false;
266
294
    copy->to_field->reset();
267
295
  }
268
296
  else
270
298
}
271
299
 
272
300
 
273
 
static void do_copy_blob(Copy_field *copy)
 
301
static void do_copy_blob(CopyField *copy)
274
302
{
275
 
  ulong length=((Field_blob*) copy->from_field)->get_length();
 
303
  ulong length= ((Field_blob*) copy->from_field)->get_length();
276
304
  ((Field_blob*) copy->to_field)->store_length(length);
277
 
  memcpy(copy->to_ptr,copy->from_ptr,sizeof(char*));
 
305
  memcpy(copy->to_ptr, copy->from_ptr, sizeof(char*));
278
306
}
279
307
 
280
 
static void do_conv_blob(Copy_field *copy)
 
308
static void do_conv_blob(CopyField *copy)
281
309
{
282
 
  copy->from_field->val_str(&copy->tmp);
 
310
  copy->from_field->val_str_internal(&copy->tmp);
283
311
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
284
 
                                         copy->tmp.length(),
285
 
                                         copy->tmp.charset());
 
312
                                         copy->tmp.length(),
 
313
                                         copy->tmp.charset());
286
314
}
287
315
 
288
316
/** Save blob in copy->tmp for GROUP BY. */
289
317
 
290
 
static void do_save_blob(Copy_field *copy)
 
318
static void do_save_blob(CopyField *copy)
291
319
{
292
320
  char buff[MAX_FIELD_WIDTH];
293
 
  String res(buff,sizeof(buff),copy->tmp.charset());
294
 
  copy->from_field->val_str(&res);
 
321
  String res(buff, sizeof(buff), copy->tmp.charset());
 
322
  copy->from_field->val_str_internal(&res);
295
323
  copy->tmp.copy(res);
296
324
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
297
 
                                         copy->tmp.length(),
298
 
                                         copy->tmp.charset());
 
325
                                         copy->tmp.length(),
 
326
                                         copy->tmp.charset());
299
327
}
300
328
 
301
329
 
302
 
static void do_field_string(Copy_field *copy)
 
330
static void do_field_string(CopyField *copy)
303
331
{
304
332
  char buff[MAX_FIELD_WIDTH];
305
333
  copy->tmp.set_quick(buff,sizeof(buff),copy->tmp.charset());
306
 
  copy->from_field->val_str(&copy->tmp);
 
334
  copy->from_field->val_str_internal(&copy->tmp);
307
335
  copy->to_field->store(copy->tmp.c_ptr_quick(),copy->tmp.length(),
308
336
                        copy->tmp.charset());
309
337
}
310
338
 
311
339
 
312
 
static void do_field_enum(Copy_field *copy)
 
340
static void do_field_enum(CopyField *copy)
313
341
{
314
342
  if (copy->from_field->val_int() == 0)
315
343
    ((Field_enum *) copy->to_field)->store_type((uint64_t) 0);
318
346
}
319
347
 
320
348
 
321
 
static void do_field_int(Copy_field *copy)
 
349
static void do_field_int(CopyField *copy)
322
350
{
323
351
  int64_t value= copy->from_field->val_int();
324
352
  copy->to_field->store(value,
325
353
                        test(copy->from_field->flags & UNSIGNED_FLAG));
326
354
}
327
355
 
328
 
static void do_field_real(Copy_field *copy)
 
356
static void do_field_real(CopyField *copy)
329
357
{
330
358
  double value=copy->from_field->val_real();
331
359
  copy->to_field->store(value);
332
360
}
333
361
 
334
362
 
335
 
static void do_field_decimal(Copy_field *copy)
 
363
static void do_field_decimal(CopyField *copy)
336
364
{
337
365
  my_decimal value;
338
366
  copy->to_field->store_decimal(copy->from_field->val_decimal(&value));
344
372
  from string.
345
373
*/
346
374
 
347
 
static void do_cut_string(Copy_field *copy)
 
375
static void do_cut_string(CopyField *copy)
348
376
{
349
377
  const CHARSET_INFO * const cs= copy->from_field->charset();
350
378
  memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
366
394
  from string.
367
395
*/
368
396
 
369
 
static void do_cut_string_complex(Copy_field *copy)
 
397
static void do_cut_string_complex(CopyField *copy)
370
398
{                                               // Shorter string field
371
399
  int well_formed_error;
372
400
  const CHARSET_INFO * const cs= copy->from_field->charset();
373
 
  const uchar *from_end= copy->from_ptr + copy->from_length;
374
 
  uint copy_length= cs->cset->well_formed_len(cs,
 
401
  const unsigned char *from_end= copy->from_ptr + copy->from_length;
 
402
  uint32_t copy_length= cs->cset->well_formed_len(cs,
375
403
                                              (char*) copy->from_ptr,
376
 
                                              (char*) from_end, 
 
404
                                              (char*) from_end,
377
405
                                              copy->to_length / cs->mbmaxlen,
378
406
                                              &well_formed_error);
379
407
  if (copy->to_length < copy_length)
398
426
 
399
427
 
400
428
 
401
 
static void do_expand_binary(Copy_field *copy)
402
 
{
403
 
  const CHARSET_INFO * const cs= copy->from_field->charset();
404
 
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
405
 
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
406
 
                     copy->to_length-copy->from_length, '\0');
407
 
}
408
 
 
409
 
 
410
 
 
411
 
static void do_expand_string(Copy_field *copy)
412
 
{
413
 
  const CHARSET_INFO * const cs= copy->from_field->charset();
414
 
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
415
 
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
416
 
                     copy->to_length-copy->from_length, ' ');
417
 
}
418
 
 
419
 
 
420
 
static void do_varstring1(Copy_field *copy)
421
 
{
422
 
  uint length= (uint) *(uchar*) copy->from_ptr;
 
429
static void do_expand_binary(CopyField *copy)
 
430
{
 
431
  const CHARSET_INFO * const cs= copy->from_field->charset();
 
432
  memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
 
433
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
 
434
                 copy->to_length-copy->from_length, '\0');
 
435
}
 
436
 
 
437
 
 
438
 
 
439
static void do_expand_string(CopyField *copy)
 
440
{
 
441
  const CHARSET_INFO * const cs= copy->from_field->charset();
 
442
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
443
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
 
444
                 copy->to_length-copy->from_length, ' ');
 
445
}
 
446
 
 
447
 
 
448
static void do_varstring1(CopyField *copy)
 
449
{
 
450
  uint32_t length= (uint32_t) *(unsigned char*) copy->from_ptr;
423
451
  if (length > copy->to_length- 1)
424
452
  {
425
 
    length=copy->to_length - 1;
426
 
    if (copy->from_field->table->in_use->count_cuted_fields)
 
453
    length= copy->to_length - 1;
 
454
    if (copy->from_field->getTable()->in_use->count_cuted_fields)
427
455
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
428
456
                                  ER_WARN_DATA_TRUNCATED, 1);
429
457
  }
430
 
  *(uchar*) copy->to_ptr= (uchar) length;
 
458
  *(unsigned char*) copy->to_ptr= (unsigned char) length;
431
459
  memcpy(copy->to_ptr+1, copy->from_ptr + 1, length);
432
460
}
433
461
 
434
462
 
435
 
static void do_varstring1_mb(Copy_field *copy)
 
463
static void do_varstring1_mb(CopyField *copy)
436
464
{
437
465
  int well_formed_error;
438
466
  const CHARSET_INFO * const cs= copy->from_field->charset();
439
 
  uint from_length= (uint) *(uchar*) copy->from_ptr;
440
 
  const uchar *from_ptr= copy->from_ptr + 1;
441
 
  uint to_char_length= (copy->to_length - 1) / cs->mbmaxlen;
442
 
  uint length= cs->cset->well_formed_len(cs, (char*) from_ptr,
 
467
  uint32_t from_length= (uint32_t) *(unsigned char*) copy->from_ptr;
 
468
  const unsigned char *from_ptr= copy->from_ptr + 1;
 
469
  uint32_t to_char_length= (copy->to_length - 1) / cs->mbmaxlen;
 
470
  uint32_t length= cs->cset->well_formed_len(cs, (char*) from_ptr,
443
471
                                         (char*) from_ptr + from_length,
444
472
                                         to_char_length, &well_formed_error);
445
473
  if (length < from_length)
446
474
  {
447
 
    if (current_thd->count_cuted_fields)
 
475
    if (current_session->count_cuted_fields)
448
476
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
449
477
                                  ER_WARN_DATA_TRUNCATED, 1);
450
478
  }
451
 
  *copy->to_ptr= (uchar) length;
 
479
  *copy->to_ptr= (unsigned char) length;
452
480
  memcpy(copy->to_ptr + 1, from_ptr, length);
453
481
}
454
482
 
455
483
 
456
 
static void do_varstring2(Copy_field *copy)
 
484
static void do_varstring2(CopyField *copy)
457
485
{
458
 
  uint length=uint2korr(copy->from_ptr);
 
486
  uint32_t length= uint2korr(copy->from_ptr);
459
487
  if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
460
488
  {
461
489
    length=copy->to_length-HA_KEY_BLOB_LENGTH;
462
 
    if (copy->from_field->table->in_use->count_cuted_fields)
 
490
    if (copy->from_field->getTable()->in_use->count_cuted_fields)
463
491
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
464
492
                                  ER_WARN_DATA_TRUNCATED, 1);
465
493
  }
469
497
}
470
498
 
471
499
 
472
 
static void do_varstring2_mb(Copy_field *copy)
 
500
static void do_varstring2_mb(CopyField *copy)
473
501
{
474
502
  int well_formed_error;
475
503
  const CHARSET_INFO * const cs= copy->from_field->charset();
476
 
  uint char_length= (copy->to_length - HA_KEY_BLOB_LENGTH) / cs->mbmaxlen;
477
 
  uint from_length= uint2korr(copy->from_ptr);
478
 
  const uchar *from_beg= copy->from_ptr + HA_KEY_BLOB_LENGTH;
479
 
  uint length= cs->cset->well_formed_len(cs, (char*) from_beg,
480
 
                                         (char*) from_beg + from_length,
481
 
                                         char_length, &well_formed_error);
 
504
  uint32_t char_length= (copy->to_length - HA_KEY_BLOB_LENGTH) / cs->mbmaxlen;
 
505
  uint32_t from_length= uint2korr(copy->from_ptr);
 
506
  const unsigned char *from_beg= copy->from_ptr + HA_KEY_BLOB_LENGTH;
 
507
  uint32_t length= cs->cset->well_formed_len(cs, (char*) from_beg,
 
508
                                             (char*) from_beg + from_length,
 
509
                                             char_length, &well_formed_error);
482
510
  if (length < from_length)
483
511
  {
484
 
    if (current_thd->count_cuted_fields)
 
512
    if (current_session->count_cuted_fields)
485
513
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
486
514
                                  ER_WARN_DATA_TRUNCATED, 1);
487
 
  }  
 
515
  }
488
516
  int2store(copy->to_ptr, length);
489
517
  memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, from_beg, length);
490
518
}
491
 
 
 
519
 
492
520
 
493
521
/***************************************************************************
494
 
** The different functions that fills in a Copy_field class
 
522
** The different functions that fills in a CopyField class
495
523
***************************************************************************/
496
524
 
497
525
/**
502
530
  The 'to' buffer should have a size of field->pack_length()+1
503
531
*/
504
532
 
505
 
void Copy_field::set(uchar *to,Field *from)
 
533
void CopyField::set(unsigned char *to,Field *from)
506
534
{
507
 
  from_ptr=from->ptr;
508
 
  to_ptr=to;
509
 
  from_length=from->pack_length();
 
535
  from_ptr= from->ptr;
 
536
  to_ptr= to;
 
537
  from_length= from->pack_length();
510
538
  if (from->maybe_null())
511
539
  {
512
 
    from_null_ptr=from->null_ptr;
513
 
    from_bit=     from->null_bit;
514
 
    to_ptr[0]=    1;                            // Null as default value
515
 
    to_null_ptr=  (uchar*) to_ptr++;
516
 
    to_bit=       1;
517
 
    if (from->table->maybe_null)
 
540
    from_null_ptr= from->null_ptr;
 
541
    from_bit= from->null_bit;
 
542
    to_ptr[0]= 1;                             // Null as default value
 
543
    to_null_ptr= (unsigned char*) to_ptr++;
 
544
    to_bit= 1;
 
545
    if (from->getTable()->maybe_null)
518
546
    {
519
 
      null_row=   &from->table->null_row;
520
 
      do_copy=    do_outer_field_to_null_str;
 
547
      null_row= &from->getTable()->null_row;
 
548
      do_copy= do_outer_field_to_null_str;
521
549
    }
522
550
    else
523
 
      do_copy=    do_field_to_null_str;
 
551
      do_copy= do_field_to_null_str;
524
552
  }
525
553
  else
526
554
  {
527
 
    to_null_ptr=  0;                            // For easy debugging
528
 
    do_copy=      do_field_eq;
 
555
    to_null_ptr= 0;                           // For easy debugging
 
556
    do_copy= do_field_eq;
529
557
  }
530
558
}
531
559
 
532
560
 
533
561
/*
534
 
  To do: 
 
562
  To do:
535
563
 
536
564
  If 'save\ is set to true and the 'from' is a blob field, do_copy is set to
537
565
  do_save_blob rather than do_conv_blob.  The only differences between them
538
566
  appears to be:
539
567
 
540
 
  - do_save_blob allocates and uses an intermediate buffer before calling 
541
 
    Field_blob::store. Is this in order to trigger the call to 
 
568
  - do_save_blob allocates and uses an intermediate buffer before calling
 
569
    Field_blob::store. Is this in order to trigger the call to
542
570
    well_formed_copy_nchars, by changing the pointer copy->tmp.ptr()?
543
571
    That call will take place anyway in all known cases.
544
572
 
545
 
  - The above causes a truncation to MAX_FIELD_WIDTH. Is this the intended 
 
573
  - The above causes a truncation to MAX_FIELD_WIDTH. Is this the intended
546
574
    effect? Truncation is handled by well_formed_copy_nchars anyway.
547
575
 */
548
 
void Copy_field::set(Field *to,Field *from,bool save)
 
576
void CopyField::set(Field *to,Field *from,bool save)
549
577
{
550
578
  if (to->type() == DRIZZLE_TYPE_NULL)
551
579
  {
552
 
    to_null_ptr=0;                              // For easy debugging
553
 
    to_ptr=0;
554
 
    do_copy=do_skip;
 
580
    to_null_ptr= 0;           // For easy debugging
 
581
    to_ptr= 0;
 
582
    do_copy= do_skip;
555
583
    return;
556
584
  }
557
 
  from_field=from;
558
 
  to_field=to;
559
 
  from_ptr=from->ptr;
560
 
  from_length=from->pack_length();
561
 
  to_ptr=  to->ptr;
562
 
  to_length=to_field->pack_length();
 
585
  from_field= from;
 
586
  to_field= to;
 
587
  from_ptr= from->ptr;
 
588
  from_length= from->pack_length();
 
589
  to_ptr= to->ptr;
 
590
  to_length= to_field->pack_length();
563
591
 
564
592
  // set up null handling
565
 
  from_null_ptr=to_null_ptr=0;
 
593
  from_null_ptr= to_null_ptr= 0;
566
594
  if (from->maybe_null())
567
595
  {
568
 
    from_null_ptr=      from->null_ptr;
569
 
    from_bit=           from->null_bit;
 
596
    from_null_ptr= from->null_ptr;
 
597
    from_bit= from->null_bit;
570
598
    if (to_field->real_maybe_null())
571
599
    {
572
 
      to_null_ptr=      to->null_ptr;
573
 
      to_bit=           to->null_bit;
 
600
      to_null_ptr= to->null_ptr;
 
601
      to_bit= to->null_bit;
574
602
      if (from_null_ptr)
575
 
        do_copy=        do_copy_null;
 
603
      {
 
604
        do_copy= do_copy_null;
 
605
      }
576
606
      else
577
607
      {
578
 
        null_row=       &from->table->null_row;
579
 
        do_copy=        do_outer_field_null;
 
608
        null_row= &from->getTable()->null_row;
 
609
        do_copy= do_outer_field_null;
580
610
      }
581
611
    }
582
612
    else
583
613
    {
584
614
      if (to_field->type() == DRIZZLE_TYPE_TIMESTAMP)
 
615
      {
585
616
        do_copy= do_copy_timestamp;               // Automatic timestamp
586
 
      else if (to_field == to_field->table->next_number_field)
 
617
      }
 
618
      else if (to_field == to_field->getTable()->next_number_field)
 
619
      {
587
620
        do_copy= do_copy_next_number;
 
621
      }
588
622
      else
 
623
      {
589
624
        do_copy= do_copy_not_null;
 
625
      }
590
626
    }
591
627
  }
592
628
  else if (to_field->real_maybe_null())
593
629
  {
594
 
    to_null_ptr=        to->null_ptr;
595
 
    to_bit=             to->null_bit;
 
630
    to_null_ptr= to->null_ptr;
 
631
    to_bit= to->null_bit;
596
632
    do_copy= do_copy_maybe_null;
597
633
  }
598
634
  else
599
 
   do_copy=0;
 
635
   do_copy= 0;
600
636
 
601
637
  if ((to->flags & BLOB_FLAG) && save)
602
638
    do_copy2= do_save_blob;
603
639
  else
604
640
    do_copy2= get_copy_func(to,from);
605
 
  if (!do_copy)                                 // Not null
606
 
    do_copy=do_copy2;
 
641
  if (!do_copy)         // Not null
 
642
    do_copy= do_copy2;
607
643
}
608
644
 
609
645
 
610
 
Copy_field::Copy_func *
611
 
Copy_field::get_copy_func(Field *to,Field *from)
 
646
CopyField::Copy_func *
 
647
CopyField::get_copy_func(Field *to,Field *from)
612
648
{
613
 
  bool compatible_db_low_byte_first= (to->table->s->db_low_byte_first ==
614
 
                                     from->table->s->db_low_byte_first);
 
649
  bool compatible_db_low_byte_first= (to->getTable()->getShare()->db_low_byte_first ==
 
650
                                     from->getTable()->getShare()->db_low_byte_first);
615
651
  if (to->flags & BLOB_FLAG)
616
652
  {
617
653
    if (!(from->flags & BLOB_FLAG) || from->charset() != to->charset())
619
655
    if (from_length != to_length || !compatible_db_low_byte_first)
620
656
    {
621
657
      // Correct pointer to point at char pointer
622
 
      to_ptr+=   to_length - to->table->s->blob_ptr_size;
623
 
      from_ptr+= from_length- from->table->s->blob_ptr_size;
 
658
      to_ptr+= to_length - to->getTable()->getShare()->blob_ptr_size;
 
659
      from_ptr+= from_length- from->getTable()->getShare()->blob_ptr_size;
624
660
      return do_copy_blob;
625
661
    }
626
662
  }
628
664
  {
629
665
    if (to->result_type() == DECIMAL_RESULT)
630
666
      return do_field_decimal;
 
667
      
631
668
    // Check if identical fields
632
669
    if (from->result_type() == STRING_RESULT)
633
670
    {
637
674
      */
638
675
      if (to->real_type() != from->real_type() ||
639
676
          !compatible_db_low_byte_first ||
640
 
          (((to->table->in_use->variables.sql_mode & (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) && to->type() == DRIZZLE_TYPE_NEWDATE) || to->type() == DRIZZLE_TYPE_DATETIME))
 
677
          (((to->getTable()->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) && to->type() == DRIZZLE_TYPE_DATE) || to->type() == DRIZZLE_TYPE_DATETIME))
641
678
      {
642
 
        if (from->real_type() == DRIZZLE_TYPE_ENUM)
643
 
          if (to->result_type() != STRING_RESULT)
644
 
            return do_field_int;                // Convert SET to number
645
 
        return do_field_string;
 
679
        if (from->real_type() == DRIZZLE_TYPE_ENUM)
 
680
        {
 
681
          if (to->result_type() != STRING_RESULT)
 
682
          {
 
683
            return do_field_int;  // Convert SET to number
 
684
          }
 
685
 
 
686
          return do_field_string;
 
687
        }
646
688
      }
 
689
 
647
690
      if (to->real_type() == DRIZZLE_TYPE_ENUM)
648
691
      {
649
 
        if (!to->eq_def(from))
 
692
        if (!to->eq_def(from))
650
693
        {
651
694
          if (from->real_type() == DRIZZLE_TYPE_ENUM &&
652
695
              to->real_type() == DRIZZLE_TYPE_ENUM)
656
699
        }
657
700
      }
658
701
      else if (to->charset() != from->charset())
659
 
        return do_field_string;
 
702
        return do_field_string;
660
703
      else if (to->real_type() == DRIZZLE_TYPE_VARCHAR)
661
704
      {
662
 
        if (((Field_varstring*) to)->length_bytes !=
663
 
            ((Field_varstring*) from)->length_bytes)
664
 
          return do_field_string;
 
705
        /* Field_blob is not part of the Field_varstring hierarchy,
 
706
          and casting to varstring for calling pack_length_no_ptr()
 
707
          is always incorrect. Previously the below comparison has
 
708
          always evaluated to false as pack_length_no_ptr() for BLOB
 
709
          will return 4 and varstring can only be <= 2.
 
710
          If your brain slightly bleeds as to why this worked for
 
711
          so many years, you are in no way alone.
 
712
        */
 
713
        if (from->flags & BLOB_FLAG)
 
714
          return do_field_string;
 
715
 
 
716
        if ((static_cast<Field_varstring*>(to))->pack_length_no_ptr() !=
 
717
            (static_cast<Field_varstring*>(from))->pack_length_no_ptr())
 
718
        {
 
719
          return do_field_string;
 
720
        }
 
721
 
665
722
        if (to_length != from_length)
666
 
          return (((Field_varstring*) to)->length_bytes == 1 ?
 
723
        {
 
724
          return (((Field_varstring*) to)->pack_length_no_ptr() == 1 ?
667
725
                  (from->charset()->mbmaxlen == 1 ? do_varstring1 :
668
 
                                                    do_varstring1_mb) :
 
726
                   do_varstring1_mb) :
669
727
                  (from->charset()->mbmaxlen == 1 ? do_varstring2 :
670
 
                                                    do_varstring2_mb));
 
728
                   do_varstring2_mb));
 
729
        }
671
730
      }
672
731
      else if (to_length < from_length)
673
 
        return (from->charset()->mbmaxlen == 1 ?
 
732
      {
 
733
        return (from->charset()->mbmaxlen == 1 ?
674
734
                do_cut_string : do_cut_string_complex);
 
735
      }
675
736
      else if (to_length > from_length)
676
737
      {
677
738
        if (to->charset() == &my_charset_bin)
679
740
        else
680
741
          return do_expand_string;
681
742
      }
682
 
 
683
743
    }
684
744
    else if (to->real_type() != from->real_type() ||
685
 
             to_length != from_length ||
 
745
             to_length != from_length ||
686
746
             !compatible_db_low_byte_first)
687
747
    {
688
748
      if (to->result_type() == STRING_RESULT)
689
 
        return do_field_string;
 
749
        return do_field_string;
690
750
      if (to->result_type() == INT_RESULT)
691
 
        return do_field_int;
 
751
        return do_field_int;
 
752
 
692
753
      return do_field_real;
693
754
    }
694
755
    else
695
756
    {
696
757
      if (!to->eq_def(from) || !compatible_db_low_byte_first)
697
758
      {
698
 
        if (to->result_type() == INT_RESULT)
699
 
          return do_field_int;
700
 
        else
701
 
          return do_field_real;
 
759
        if (to->result_type() == INT_RESULT)
 
760
          return do_field_int;
 
761
        else
 
762
          return do_field_real;
702
763
      }
703
764
    }
704
765
  }
 
766
  
705
767
    /* Eq fields */
706
 
  switch (to_length) {
 
768
  switch (to_length)
 
769
  {
707
770
  case 1: return do_field_1;
708
771
  case 2: return do_field_2;
709
772
  case 3: return do_field_3;
711
774
  case 6: return do_field_6;
712
775
  case 8: return do_field_8;
713
776
  }
 
777
  
714
778
  return do_field_eq;
715
779
}
716
780
 
720
784
int field_conv(Field *to,Field *from)
721
785
{
722
786
  if (to->real_type() == from->real_type() &&
723
 
      !(to->type() == DRIZZLE_TYPE_BLOB && to->table->copy_blobs))
 
787
      !(to->type() == DRIZZLE_TYPE_BLOB && to->getTable()->copy_blobs))
724
788
  {
725
789
    /* Please god, will someone rewrite this to be readable :( */
726
 
    if (to->pack_length() == from->pack_length() && 
727
 
        !(to->flags & UNSIGNED_FLAG && !(from->flags & UNSIGNED_FLAG)) && 
728
 
        to->real_type() != DRIZZLE_TYPE_ENUM && 
729
 
        (to->real_type() != DRIZZLE_TYPE_NEWDECIMAL || (to->field_length == from->field_length && (((Field_num*)to)->dec == ((Field_num*)from)->dec))) &&
 
790
    if (to->pack_length() == from->pack_length() &&
 
791
        !(to->flags & UNSIGNED_FLAG && !(from->flags & UNSIGNED_FLAG)) &&
 
792
        to->real_type() != DRIZZLE_TYPE_ENUM &&
 
793
        (to->real_type() != DRIZZLE_TYPE_DECIMAL || (to->field_length == from->field_length && (((Field_num*)to)->dec == ((Field_num*)from)->dec))) &&
730
794
        from->charset() == to->charset() &&
731
 
        to->table->s->db_low_byte_first == from->table->s->db_low_byte_first &&
732
 
        (!(to->table->in_use->variables.sql_mode & (MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) || (to->type() != DRIZZLE_TYPE_NEWDATE && to->type() != DRIZZLE_TYPE_DATETIME)) && 
733
 
        (from->real_type() != DRIZZLE_TYPE_VARCHAR || ((Field_varstring*)from)->length_bytes == ((Field_varstring*)to)->length_bytes))
 
795
        to->getTable()->getShare()->db_low_byte_first == from->getTable()->getShare()->db_low_byte_first &&
 
796
        (!(to->getTable()->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) || (to->type() != DRIZZLE_TYPE_DATE && to->type() != DRIZZLE_TYPE_DATETIME)) &&
 
797
        (from->real_type() != DRIZZLE_TYPE_VARCHAR || ((Field_varstring*)from)->pack_length_no_ptr() == ((Field_varstring*)to)->pack_length_no_ptr()))
734
798
    {                                           // Identical fields
735
 
#ifdef HAVE_purify
736
799
      /* This may happen if one does 'UPDATE ... SET x=x' */
737
800
      if (to->ptr != from->ptr)
738
 
#endif
739
801
        memcpy(to->ptr,from->ptr,to->pack_length());
740
802
      return 0;
741
803
    }
743
805
  if (to->type() == DRIZZLE_TYPE_BLOB)
744
806
  {                                             // Be sure the value is stored
745
807
    Field_blob *blob=(Field_blob*) to;
746
 
    from->val_str(&blob->value);
 
808
    from->val_str_internal(&blob->value);
747
809
    /*
748
810
      Copy value if copy_blobs is set, or source is not a string and
749
811
      we have a pointer to its internal string conversion buffer.
750
812
    */
751
 
    if (to->table->copy_blobs ||
 
813
    if (to->getTable()->copy_blobs ||
752
814
        (!blob->value.is_alloced() &&
753
815
         from->real_type() != DRIZZLE_TYPE_VARCHAR))
754
816
      blob->value.copy();
767
829
  {
768
830
    char buff[MAX_FIELD_WIDTH];
769
831
    String result(buff,sizeof(buff),from->charset());
770
 
    from->val_str(&result);
 
832
    from->val_str_internal(&result);
771
833
    /*
772
834
      We use c_ptr_quick() here to make it easier if to is a float/double
773
835
      as the conversion routines will do a copy of the result doesn't
786
848
  else
787
849
    return to->store(from->val_int(), test(from->flags & UNSIGNED_FLAG));
788
850
}
 
851
 
 
852
} /* namespace drizzled */