← 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-08 18:41:57 UTC
  • mto: This revision was merged to the branch mainline in revision 1063.
  • Revision ID: nathanlws@gmail.com-20090608184157-546phz9al1lrjoat
More style cleanup in files associated with Copy_field to CopyField change. Primarily spacing after = operator.

Lots of tabs, indendation, and reformatting for readability in field_conv.cc.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field_conv.cc
48
48
 
49
49
static void do_field_eq(CopyField *copy)
50
50
{
51
 
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
51
  memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
52
52
}
53
53
 
54
54
static void do_field_1(CopyField *copy)
55
55
{
56
 
  copy->to_ptr[0]=copy->from_ptr[0];
 
56
  copy->to_ptr[0]= copy->from_ptr[0];
57
57
}
58
58
 
59
59
static void do_field_2(CopyField *copy)
60
60
{
61
 
  copy->to_ptr[0]=copy->from_ptr[0];
62
 
  copy->to_ptr[1]=copy->from_ptr[1];
 
61
  copy->to_ptr[0]= copy->from_ptr[0];
 
62
  copy->to_ptr[1]= copy->from_ptr[1];
63
63
}
64
64
 
65
65
static void do_field_3(CopyField *copy)
66
66
{
67
 
  copy->to_ptr[0]=copy->from_ptr[0];
68
 
  copy->to_ptr[1]=copy->from_ptr[1];
69
 
  copy->to_ptr[2]=copy->from_ptr[2];
 
67
  copy->to_ptr[0]= copy->from_ptr[0];
 
68
  copy->to_ptr[1]= copy->from_ptr[1];
 
69
  copy->to_ptr[2]= copy->from_ptr[2];
70
70
}
71
71
 
72
72
static void do_field_4(CopyField *copy)
73
73
{
74
 
  copy->to_ptr[0]=copy->from_ptr[0];
75
 
  copy->to_ptr[1]=copy->from_ptr[1];
76
 
  copy->to_ptr[2]=copy->from_ptr[2];
77
 
  copy->to_ptr[3]=copy->from_ptr[3];
 
74
  copy->to_ptr[0]= copy->from_ptr[0];
 
75
  copy->to_ptr[1]= copy->from_ptr[1];
 
76
  copy->to_ptr[2]= copy->from_ptr[2];
 
77
  copy->to_ptr[3]= copy->from_ptr[3];
78
78
}
79
79
 
80
80
static void do_field_6(CopyField *copy)
81
 
{                                               // For blob field
82
 
  copy->to_ptr[0]=copy->from_ptr[0];
83
 
  copy->to_ptr[1]=copy->from_ptr[1];
84
 
  copy->to_ptr[2]=copy->from_ptr[2];
85
 
  copy->to_ptr[3]=copy->from_ptr[3];
86
 
  copy->to_ptr[4]=copy->from_ptr[4];
87
 
  copy->to_ptr[5]=copy->from_ptr[5];
 
81
{                  // For blob field
 
82
  copy->to_ptr[0]= copy->from_ptr[0];
 
83
  copy->to_ptr[1]= copy->from_ptr[1];
 
84
  copy->to_ptr[2]= copy->from_ptr[2];
 
85
  copy->to_ptr[3]= copy->from_ptr[3];
 
86
  copy->to_ptr[4]= copy->from_ptr[4];
 
87
  copy->to_ptr[5]= copy->from_ptr[5];
88
88
}
89
89
 
90
90
static void do_field_8(CopyField *copy)
91
91
{
92
 
  copy->to_ptr[0]=copy->from_ptr[0];
93
 
  copy->to_ptr[1]=copy->from_ptr[1];
94
 
  copy->to_ptr[2]=copy->from_ptr[2];
95
 
  copy->to_ptr[3]=copy->from_ptr[3];
96
 
  copy->to_ptr[4]=copy->from_ptr[4];
97
 
  copy->to_ptr[5]=copy->from_ptr[5];
98
 
  copy->to_ptr[6]=copy->from_ptr[6];
99
 
  copy->to_ptr[7]=copy->from_ptr[7];
 
92
  copy->to_ptr[0]= copy->from_ptr[0];
 
93
  copy->to_ptr[1]= copy->from_ptr[1];
 
94
  copy->to_ptr[2]= copy->from_ptr[2];
 
95
  copy->to_ptr[3]= copy->from_ptr[3];
 
96
  copy->to_ptr[4]= copy->from_ptr[4];
 
97
  copy->to_ptr[5]= copy->from_ptr[5];
 
98
  copy->to_ptr[6]= copy->from_ptr[6];
 
99
  copy->to_ptr[7]= copy->from_ptr[7];
100
100
}
101
101
 
102
102
 
105
105
  if (*copy->from_null_ptr & copy->from_bit)
106
106
  {
107
107
    memset(copy->to_ptr, 0, copy->from_length);
108
 
    copy->to_null_ptr[0]=1;                     // Always bit 1
 
108
    copy->to_null_ptr[0]= 1;  // Always bit 1
109
109
  }
110
110
  else
111
111
  {
112
 
    copy->to_null_ptr[0]=0;
113
 
    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
112
    copy->to_null_ptr[0]= 0;
 
113
    memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
114
114
  }
115
115
}
116
116
 
121
121
      (copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
122
122
  {
123
123
    memset(copy->to_ptr, 0, copy->from_length);
124
 
    copy->to_null_ptr[0]=1;                     // Always bit 1
 
124
    copy->to_null_ptr[0]= 1;  // Always bit 1
125
125
  }
126
126
  else
127
127
  {
128
 
    copy->to_null_ptr[0]=0;
129
 
    memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
128
    copy->to_null_ptr[0]= 0;
 
129
    memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
130
130
  }
131
131
}
132
132
 
217
217
{
218
218
  if (*copy->from_null_ptr & copy->from_bit)
219
219
  {
220
 
    *copy->to_null_ptr|=copy->to_bit;
 
220
    *copy->to_null_ptr|= copy->to_bit;
221
221
    copy->to_field->reset();
222
222
  }
223
223
  else
292
292
 
293
293
static void do_copy_blob(CopyField *copy)
294
294
{
295
 
  ulong length=((Field_blob*) copy->from_field)->get_length();
 
295
  ulong length= ((Field_blob*) copy->from_field)->get_length();
296
296
  ((Field_blob*) copy->to_field)->store_length(length);
297
 
  memcpy(copy->to_ptr,copy->from_ptr,sizeof(char*));
 
297
  memcpy(copy->to_ptr, copy->from_ptr, sizeof(char*));
298
298
}
299
299
 
300
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(),
304
 
                                         copy->tmp.length(),
305
 
                                         copy->tmp.charset());
 
304
                                         copy->tmp.length(),
 
305
                                         copy->tmp.charset());
306
306
}
307
307
 
308
308
/** Save blob in copy->tmp for GROUP BY. */
310
310
static void do_save_blob(CopyField *copy)
311
311
{
312
312
  char buff[MAX_FIELD_WIDTH];
313
 
  String res(buff,sizeof(buff),copy->tmp.charset());
 
313
  String res(buff, sizeof(buff), copy->tmp.charset());
314
314
  copy->from_field->val_str(&res);
315
315
  copy->tmp.copy(res);
316
316
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
317
 
                                         copy->tmp.length(),
318
 
                                         copy->tmp.charset());
 
317
                                         copy->tmp.length(),
 
318
                                         copy->tmp.charset());
319
319
}
320
320
 
321
321
 
421
421
static void do_expand_binary(CopyField *copy)
422
422
{
423
423
  const CHARSET_INFO * const cs= copy->from_field->charset();
424
 
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
 
424
  memcpy(copy->to_ptr, copy->from_ptr, copy->from_length);
425
425
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
426
 
                     copy->to_length-copy->from_length, '\0');
 
426
                 copy->to_length-copy->from_length, '\0');
427
427
}
428
428
 
429
429
 
433
433
  const CHARSET_INFO * const cs= copy->from_field->charset();
434
434
  memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
435
435
  cs->cset->fill(cs, (char*) copy->to_ptr+copy->from_length,
436
 
                     copy->to_length-copy->from_length, ' ');
 
436
                 copy->to_length-copy->from_length, ' ');
437
437
}
438
438
 
439
439
 
442
442
  uint32_t length= (uint32_t) *(unsigned char*) copy->from_ptr;
443
443
  if (length > copy->to_length- 1)
444
444
  {
445
 
    length=copy->to_length - 1;
 
445
    length= copy->to_length - 1;
446
446
    if (copy->from_field->table->in_use->count_cuted_fields)
447
447
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
448
448
                                  ER_WARN_DATA_TRUNCATED, 1);
475
475
 
476
476
static void do_varstring2(CopyField *copy)
477
477
{
478
 
  uint32_t length=uint2korr(copy->from_ptr);
 
478
  uint32_t length= uint2korr(copy->from_ptr);
479
479
  if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
480
480
  {
481
481
    length=copy->to_length-HA_KEY_BLOB_LENGTH;
497
497
  uint32_t from_length= uint2korr(copy->from_ptr);
498
498
  const unsigned char *from_beg= copy->from_ptr + HA_KEY_BLOB_LENGTH;
499
499
  uint32_t length= cs->cset->well_formed_len(cs, (char*) from_beg,
500
 
                                         (char*) from_beg + from_length,
501
 
                                         char_length, &well_formed_error);
 
500
                                             (char*) from_beg + from_length,
 
501
                                             char_length, &well_formed_error);
502
502
  if (length < from_length)
503
503
  {
504
504
    if (current_session->count_cuted_fields)
524
524
 
525
525
void CopyField::set(unsigned char *to,Field *from)
526
526
{
527
 
  from_ptr=from->ptr;
528
 
  to_ptr=to;
529
 
  from_length=from->pack_length();
 
527
  from_ptr= from->ptr;
 
528
  to_ptr= to;
 
529
  from_length= from->pack_length();
530
530
  if (from->maybe_null())
531
531
  {
532
 
    from_null_ptr=from->null_ptr;
533
 
    from_bit=     from->null_bit;
534
 
    to_ptr[0]=    1;                            // Null as default value
535
 
    to_null_ptr=  (unsigned char*) to_ptr++;
536
 
    to_bit=       1;
 
532
    from_null_ptr= from->null_ptr;
 
533
    from_bit= from->null_bit;
 
534
    to_ptr[0]= 1;                             // Null as default value
 
535
    to_null_ptr= (unsigned char*) to_ptr++;
 
536
    to_bit= 1;
537
537
    if (from->table->maybe_null)
538
538
    {
539
 
      null_row=   &from->table->null_row;
540
 
      do_copy=    do_outer_field_to_null_str;
 
539
      null_row= &from->table->null_row;
 
540
      do_copy= do_outer_field_to_null_str;
541
541
    }
542
542
    else
543
 
      do_copy=    do_field_to_null_str;
 
543
      do_copy= do_field_to_null_str;
544
544
  }
545
545
  else
546
546
  {
547
 
    to_null_ptr=  0;                            // For easy debugging
548
 
    do_copy=      do_field_eq;
 
547
    to_null_ptr= 0;                           // For easy debugging
 
548
    do_copy= do_field_eq;
549
549
  }
550
550
}
551
551
 
569
569
{
570
570
  if (to->type() == DRIZZLE_TYPE_NULL)
571
571
  {
572
 
    to_null_ptr=0;                              // For easy debugging
573
 
    to_ptr=0;
574
 
    do_copy=do_skip;
 
572
    to_null_ptr= 0;           // For easy debugging
 
573
    to_ptr= 0;
 
574
    do_copy= do_skip;
575
575
    return;
576
576
  }
577
 
  from_field=from;
578
 
  to_field=to;
579
 
  from_ptr=from->ptr;
580
 
  from_length=from->pack_length();
581
 
  to_ptr=  to->ptr;
582
 
  to_length=to_field->pack_length();
 
577
  from_field= from;
 
578
  to_field= to;
 
579
  from_ptr= from->ptr;
 
580
  from_length= from->pack_length();
 
581
  to_ptr= to->ptr;
 
582
  to_length= to_field->pack_length();
583
583
 
584
584
  // set up null handling
585
 
  from_null_ptr=to_null_ptr=0;
 
585
  from_null_ptr= to_null_ptr= 0;
586
586
  if (from->maybe_null())
587
587
  {
588
 
    from_null_ptr=      from->null_ptr;
589
 
    from_bit=           from->null_bit;
 
588
    from_null_ptr= from->null_ptr;
 
589
    from_bit= from->null_bit;
590
590
    if (to_field->real_maybe_null())
591
591
    {
592
 
      to_null_ptr=      to->null_ptr;
593
 
      to_bit=           to->null_bit;
 
592
      to_null_ptr= to->null_ptr;
 
593
      to_bit= to->null_bit;
594
594
      if (from_null_ptr)
595
 
        do_copy=        do_copy_null;
 
595
        do_copy= do_copy_null;
596
596
      else
597
597
      {
598
 
        null_row=       &from->table->null_row;
599
 
        do_copy=        do_outer_field_null;
 
598
        null_row= &from->table->null_row;
 
599
        do_copy= do_outer_field_null;
600
600
      }
601
601
    }
602
602
    else
611
611
  }
612
612
  else if (to_field->real_maybe_null())
613
613
  {
614
 
    to_null_ptr=        to->null_ptr;
615
 
    to_bit=             to->null_bit;
 
614
    to_null_ptr= to->null_ptr;
 
615
    to_bit= to->null_bit;
616
616
    do_copy= do_copy_maybe_null;
617
617
  }
618
618
  else
619
 
   do_copy=0;
 
619
   do_copy= 0;
620
620
 
621
621
  if ((to->flags & BLOB_FLAG) && save)
622
622
    do_copy2= do_save_blob;
623
623
  else
624
624
    do_copy2= get_copy_func(to,from);
625
 
  if (!do_copy)                                 // Not null
626
 
    do_copy=do_copy2;
 
625
  if (!do_copy)         // Not null
 
626
    do_copy= do_copy2;
627
627
}
628
628
 
629
629
 
639
639
    if (from_length != to_length || !compatible_db_low_byte_first)
640
640
    {
641
641
      // Correct pointer to point at char pointer
642
 
      to_ptr+=   to_length - to->table->s->blob_ptr_size;
 
642
      to_ptr+= to_length - to->table->s->blob_ptr_size;
643
643
      from_ptr+= from_length- from->table->s->blob_ptr_size;
644
644
      return do_copy_blob;
645
645
    }
648
648
  {
649
649
    if (to->result_type() == DECIMAL_RESULT)
650
650
      return do_field_decimal;
 
651
      
651
652
    // Check if identical fields
652
653
    if (from->result_type() == STRING_RESULT)
653
654
    {
659
660
          !compatible_db_low_byte_first ||
660
661
          (((to->table->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) && to->type() == DRIZZLE_TYPE_DATE) || to->type() == DRIZZLE_TYPE_DATETIME))
661
662
      {
662
 
        if (from->real_type() == DRIZZLE_TYPE_ENUM)
663
 
          if (to->result_type() != STRING_RESULT)
664
 
            return do_field_int;                // Convert SET to number
665
 
        return do_field_string;
 
663
        if (from->real_type() == DRIZZLE_TYPE_ENUM)
 
664
        {
 
665
          if (to->result_type() != STRING_RESULT)
 
666
          {
 
667
            return do_field_int;  // Convert SET to number
 
668
          }
 
669
          
 
670
          return do_field_string;
 
671
        }
666
672
      }
 
673
      
667
674
      if (to->real_type() == DRIZZLE_TYPE_ENUM)
668
675
      {
669
 
        if (!to->eq_def(from))
 
676
        if (!to->eq_def(from))
670
677
        {
671
678
          if (from->real_type() == DRIZZLE_TYPE_ENUM &&
672
679
              to->real_type() == DRIZZLE_TYPE_ENUM)
676
683
        }
677
684
      }
678
685
      else if (to->charset() != from->charset())
679
 
        return do_field_string;
 
686
        return do_field_string;
680
687
      else if (to->real_type() == DRIZZLE_TYPE_VARCHAR)
681
688
      {
682
689
        if (((Field_varstring*) to)->length_bytes !=
683
690
            ((Field_varstring*) from)->length_bytes)
 
691
        {
684
692
          return do_field_string;
 
693
        }
 
694
        
685
695
        if (to_length != from_length)
 
696
        {
686
697
          return (((Field_varstring*) to)->length_bytes == 1 ?
687
698
                  (from->charset()->mbmaxlen == 1 ? do_varstring1 :
688
699
                                                    do_varstring1_mb) :
689
700
                  (from->charset()->mbmaxlen == 1 ? do_varstring2 :
690
701
                                                    do_varstring2_mb));
 
702
        }
691
703
      }
692
704
      else if (to_length < from_length)
693
 
        return (from->charset()->mbmaxlen == 1 ?
 
705
      {
 
706
        return (from->charset()->mbmaxlen == 1 ?
694
707
                do_cut_string : do_cut_string_complex);
 
708
      }
695
709
      else if (to_length > from_length)
696
710
      {
697
711
        if (to->charset() == &my_charset_bin)
699
713
        else
700
714
          return do_expand_string;
701
715
      }
702
 
 
703
716
    }
704
717
    else if (to->real_type() != from->real_type() ||
705
 
             to_length != from_length ||
 
718
             to_length != from_length ||
706
719
             !compatible_db_low_byte_first)
707
720
    {
708
721
      if (to->result_type() == STRING_RESULT)
709
 
        return do_field_string;
 
722
        return do_field_string;
710
723
      if (to->result_type() == INT_RESULT)
711
 
        return do_field_int;
 
724
        return do_field_int;
 
725
 
712
726
      return do_field_real;
713
727
    }
714
728
    else
715
729
    {
716
730
      if (!to->eq_def(from) || !compatible_db_low_byte_first)
717
731
      {
718
 
        if (to->result_type() == INT_RESULT)
719
 
          return do_field_int;
720
 
        else
721
 
          return do_field_real;
 
732
        if (to->result_type() == INT_RESULT)
 
733
          return do_field_int;
 
734
        else
 
735
          return do_field_real;
722
736
      }
723
737
    }
724
738
  }
 
739
  
725
740
    /* Eq fields */
726
 
  switch (to_length) {
 
741
  switch (to_length)
 
742
  {
727
743
  case 1: return do_field_1;
728
744
  case 2: return do_field_2;
729
745
  case 3: return do_field_3;
731
747
  case 6: return do_field_6;
732
748
  case 8: return do_field_8;
733
749
  }
 
750
  
734
751
  return do_field_eq;
735
752
}
736
753