← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field_conv.cc

  • Committer: Nathan Williams
  • Date: 2009-06-05 22:22:21 UTC
  • mto: This revision was merged to the branch mainline in revision 1063.
  • Revision ID: nathanlws@gmail.com-20090605222221-usmgpjhggrwjgz9w
No actual code changes. Changed Copy_field to CopyField, to reflect the coding standards.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field_conv.cc
46
46
#include <drizzled/field/varstring.h>
47
47
 
48
48
 
49
 
static void do_field_eq(Copy_field *copy)
 
49
static void do_field_eq(CopyField *copy)
50
50
{
51
51
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
52
52
}
53
53
 
54
 
static void do_field_1(Copy_field *copy)
 
54
static void do_field_1(CopyField *copy)
55
55
{
56
56
  copy->to_ptr[0]=copy->from_ptr[0];
57
57
}
58
58
 
59
 
static void do_field_2(Copy_field *copy)
 
59
static void do_field_2(CopyField *copy)
60
60
{
61
61
  copy->to_ptr[0]=copy->from_ptr[0];
62
62
  copy->to_ptr[1]=copy->from_ptr[1];
63
63
}
64
64
 
65
 
static void do_field_3(Copy_field *copy)
 
65
static void do_field_3(CopyField *copy)
66
66
{
67
67
  copy->to_ptr[0]=copy->from_ptr[0];
68
68
  copy->to_ptr[1]=copy->from_ptr[1];
69
69
  copy->to_ptr[2]=copy->from_ptr[2];
70
70
}
71
71
 
72
 
static void do_field_4(Copy_field *copy)
 
72
static void do_field_4(CopyField *copy)
73
73
{
74
74
  copy->to_ptr[0]=copy->from_ptr[0];
75
75
  copy->to_ptr[1]=copy->from_ptr[1];
77
77
  copy->to_ptr[3]=copy->from_ptr[3];
78
78
}
79
79
 
80
 
static void do_field_6(Copy_field *copy)
 
80
static void do_field_6(CopyField *copy)
81
81
{                                               // For blob field
82
82
  copy->to_ptr[0]=copy->from_ptr[0];
83
83
  copy->to_ptr[1]=copy->from_ptr[1];
87
87
  copy->to_ptr[5]=copy->from_ptr[5];
88
88
}
89
89
 
90
 
static void do_field_8(Copy_field *copy)
 
90
static void do_field_8(CopyField *copy)
91
91
{
92
92
  copy->to_ptr[0]=copy->from_ptr[0];
93
93
  copy->to_ptr[1]=copy->from_ptr[1];
100
100
}
101
101
 
102
102
 
103
 
static void do_field_to_null_str(Copy_field *copy)
 
103
static void do_field_to_null_str(CopyField *copy)
104
104
{
105
105
  if (*copy->from_null_ptr & copy->from_bit)
106
106
  {
115
115
}
116
116
 
117
117
 
118
 
static void do_outer_field_to_null_str(Copy_field *copy)
 
118
static void do_outer_field_to_null_str(CopyField *copy)
119
119
{
120
120
  if (*copy->null_row ||
121
121
      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
208
208
}
209
209
 
210
210
 
211
 
static void do_skip(Copy_field *)
 
211
static void do_skip(CopyField *)
212
212
{
213
213
}
214
214
 
215
215
 
216
 
static void do_copy_null(Copy_field *copy)
 
216
static void do_copy_null(CopyField *copy)
217
217
{
218
218
  if (*copy->from_null_ptr & copy->from_bit)
219
219
  {
228
228
}
229
229
 
230
230
 
231
 
static void do_outer_field_null(Copy_field *copy)
 
231
static void do_outer_field_null(CopyField *copy)
232
232
{
233
233
  if (*copy->null_row ||
234
234
      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
244
244
}
245
245
 
246
246
 
247
 
static void do_copy_not_null(Copy_field *copy)
 
247
static void do_copy_not_null(CopyField *copy)
248
248
{
249
249
  if (*copy->from_null_ptr & copy->from_bit)
250
250
  {
257
257
}
258
258
 
259
259
 
260
 
static void do_copy_maybe_null(Copy_field *copy)
 
260
static void do_copy_maybe_null(CopyField *copy)
261
261
{
262
262
  *copy->to_null_ptr&= ~copy->to_bit;
263
263
  (copy->do_copy2)(copy);
265
265
 
266
266
/* timestamp and next_number has special handling in case of NULL values */
267
267
 
268
 
static void do_copy_timestamp(Copy_field *copy)
 
268
static void do_copy_timestamp(CopyField *copy)
269
269
{
270
270
  if (*copy->from_null_ptr & copy->from_bit)
271
271
  {
277
277
}
278
278
 
279
279
 
280
 
static void do_copy_next_number(Copy_field *copy)
 
280
static void do_copy_next_number(CopyField *copy)
281
281
{
282
282
  if (*copy->from_null_ptr & copy->from_bit)
283
283
  {
290
290
}
291
291
 
292
292
 
293
 
static void do_copy_blob(Copy_field *copy)
 
293
static void do_copy_blob(CopyField *copy)
294
294
{
295
295
  ulong length=((Field_blob*) copy->from_field)->get_length();
296
296
  ((Field_blob*) copy->to_field)->store_length(length);
297
297
  memcpy(copy->to_ptr,copy->from_ptr,sizeof(char*));
298
298
}
299
299
 
300
 
static void do_conv_blob(Copy_field *copy)
 
300
static void do_conv_blob(CopyField *copy)
301
301
{
302
302
  copy->from_field->val_str(&copy->tmp);
303
303
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
307
307
 
308
308
/** Save blob in copy->tmp for GROUP BY. */
309
309
 
310
 
static void do_save_blob(Copy_field *copy)
 
310
static void do_save_blob(CopyField *copy)
311
311
{
312
312
  char buff[MAX_FIELD_WIDTH];
313
313
  String res(buff,sizeof(buff),copy->tmp.charset());
319
319
}
320
320
 
321
321
 
322
 
static void do_field_string(Copy_field *copy)
 
322
static void do_field_string(CopyField *copy)
323
323
{
324
324
  char buff[MAX_FIELD_WIDTH];
325
325
  copy->tmp.set_quick(buff,sizeof(buff),copy->tmp.charset());
329
329
}
330
330
 
331
331
 
332
 
static void do_field_enum(Copy_field *copy)
 
332
static void do_field_enum(CopyField *copy)
333
333
{
334
334
  if (copy->from_field->val_int() == 0)
335
335
    ((Field_enum *) copy->to_field)->store_type((uint64_t) 0);
338
338
}
339
339
 
340
340
 
341
 
static void do_field_int(Copy_field *copy)
 
341
static void do_field_int(CopyField *copy)
342
342
{
343
343
  int64_t value= copy->from_field->val_int();
344
344
  copy->to_field->store(value,
345
345
                        test(copy->from_field->flags & UNSIGNED_FLAG));
346
346
}
347
347
 
348
 
static void do_field_real(Copy_field *copy)
 
348
static void do_field_real(CopyField *copy)
349
349
{
350
350
  double value=copy->from_field->val_real();
351
351
  copy->to_field->store(value);
352
352
}
353
353
 
354
354
 
355
 
static void do_field_decimal(Copy_field *copy)
 
355
static void do_field_decimal(CopyField *copy)
356
356
{
357
357
  my_decimal value;
358
358
  copy->to_field->store_decimal(copy->from_field->val_decimal(&value));
364
364
  from string.
365
365
*/
366
366
 
367
 
static void do_cut_string(Copy_field *copy)
 
367
static void do_cut_string(CopyField *copy)
368
368
{
369
369
  const CHARSET_INFO * const cs= copy->from_field->charset();
370
370
  memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
386
386
  from string.
387
387
*/
388
388
 
389
 
static void do_cut_string_complex(Copy_field *copy)
 
389
static void do_cut_string_complex(CopyField *copy)
390
390
{                                               // Shorter string field
391
391
  int well_formed_error;
392
392
  const CHARSET_INFO * const cs= copy->from_field->charset();
418
418
 
419
419
 
420
420
 
421
 
static void do_expand_binary(Copy_field *copy)
 
421
static void do_expand_binary(CopyField *copy)
422
422
{
423
423
  const CHARSET_INFO * const cs= copy->from_field->charset();
424
424
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
428
428
 
429
429
 
430
430
 
431
 
static void do_expand_string(Copy_field *copy)
 
431
static void do_expand_string(CopyField *copy)
432
432
{
433
433
  const CHARSET_INFO * const cs= copy->from_field->charset();
434
434
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
437
437
}
438
438
 
439
439
 
440
 
static void do_varstring1(Copy_field *copy)
 
440
static void do_varstring1(CopyField *copy)
441
441
{
442
442
  uint32_t length= (uint32_t) *(unsigned char*) copy->from_ptr;
443
443
  if (length > copy->to_length- 1)
452
452
}
453
453
 
454
454
 
455
 
static void do_varstring1_mb(Copy_field *copy)
 
455
static void do_varstring1_mb(CopyField *copy)
456
456
{
457
457
  int well_formed_error;
458
458
  const CHARSET_INFO * const cs= copy->from_field->charset();
473
473
}
474
474
 
475
475
 
476
 
static void do_varstring2(Copy_field *copy)
 
476
static void do_varstring2(CopyField *copy)
477
477
{
478
478
  uint32_t length=uint2korr(copy->from_ptr);
479
479
  if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
489
489
}
490
490
 
491
491
 
492
 
static void do_varstring2_mb(Copy_field *copy)
 
492
static void do_varstring2_mb(CopyField *copy)
493
493
{
494
494
  int well_formed_error;
495
495
  const CHARSET_INFO * const cs= copy->from_field->charset();
511
511
 
512
512
 
513
513
/***************************************************************************
514
 
** The different functions that fills in a Copy_field class
 
514
** The different functions that fills in a CopyField class
515
515
***************************************************************************/
516
516
 
517
517
/**
522
522
  The 'to' buffer should have a size of field->pack_length()+1
523
523
*/
524
524
 
525
 
void Copy_field::set(unsigned char *to,Field *from)
 
525
void CopyField::set(unsigned char *to,Field *from)
526
526
{
527
527
  from_ptr=from->ptr;
528
528
  to_ptr=to;
565
565
  - The above causes a truncation to MAX_FIELD_WIDTH. Is this the intended
566
566
    effect? Truncation is handled by well_formed_copy_nchars anyway.
567
567
 */
568
 
void Copy_field::set(Field *to,Field *from,bool save)
 
568
void CopyField::set(Field *to,Field *from,bool save)
569
569
{
570
570
  if (to->type() == DRIZZLE_TYPE_NULL)
571
571
  {
627
627
}
628
628
 
629
629
 
630
 
Copy_field::Copy_func *
631
 
Copy_field::get_copy_func(Field *to,Field *from)
 
630
CopyField::Copy_func *
 
631
CopyField::get_copy_func(Field *to,Field *from)
632
632
{
633
633
  bool compatible_db_low_byte_first= (to->table->s->db_low_byte_first ==
634
634
                                     from->table->s->db_low_byte_first);