← 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: 2009-11-24 02:06:37 UTC
  • mfrom: (1223.1.7 push)
  • Revision ID: brian@gaz-20091124020637-9gb65vj98x1arydm
Merge for staging.

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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
 
17
17
/**
24
24
    gives much more speed.
25
25
*/
26
26
 
27
 
#include "config.h"
28
 
 
 
27
#include <drizzled/server_includes.h>
29
28
#include <drizzled/error.h>
30
29
#include <drizzled/table.h>
31
30
#include <drizzled/session.h>
32
31
 
33
 
#include <drizzled/copy_field.h>
 
32
#include <drizzled/field/str.h>
 
33
#include <drizzled/field/num.h>
34
34
#include <drizzled/field/blob.h>
 
35
#include <drizzled/field/enum.h>
 
36
#include <drizzled/field/null.h>
35
37
#include <drizzled/field/date.h>
36
 
#include <drizzled/field/datetime.h>
37
38
#include <drizzled/field/decimal.h>
 
39
#include <drizzled/field/real.h>
38
40
#include <drizzled/field/double.h>
39
 
#include <drizzled/field/enum.h>
40
 
#include <drizzled/field/epoch.h>
41
 
#include <drizzled/field/int32.h>
42
 
#include <drizzled/field/int64.h>
43
 
#include <drizzled/field/null.h>
44
 
#include <drizzled/field/num.h>
45
 
#include <drizzled/field/num.h>
46
 
#include <drizzled/field/real.h>
47
 
#include <drizzled/field/str.h>
 
41
#include <drizzled/field/long.h>
 
42
#include <drizzled/field/int64_t.h>
 
43
#include <drizzled/field/num.h>
 
44
#include <drizzled/field/timestamp.h>
 
45
#include <drizzled/field/datetime.h>
48
46
#include <drizzled/field/varstring.h>
49
47
 
50
 
namespace drizzled
51
 
{
52
48
 
53
49
static void do_field_eq(CopyField *copy)
54
50
{
145
141
    return 0;
146
142
  }
147
143
  field->reset();
148
 
  if (field->getTable()->in_use->count_cuted_fields == CHECK_FIELD_WARN)
 
144
  if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN)
149
145
  {
150
146
    field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
151
147
    return 0;
152
148
  }
153
 
  if (!field->getTable()->in_use->no_errors)
 
149
  if (!field->table->in_use->no_errors)
154
150
    my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
155
151
  return -1;
156
152
}
182
178
    field->reset();
183
179
    return 0;
184
180
  }
185
 
 
186
181
  if (no_conversions)
187
182
    return -1;
188
183
 
191
186
    when set to NULL (TIMESTAMP fields which allow setting to NULL
192
187
    are handled by first check).
193
188
  */
194
 
  if (field->is_timestamp())
 
189
  if (field->type() == DRIZZLE_TYPE_TIMESTAMP)
195
190
  {
196
 
    ((field::Epoch::pointer) field)->set_time();
 
191
    ((Field_timestamp*) field)->set_time();
197
192
    return 0;                                   // Ok to set time to NULL
198
193
  }
199
 
 
200
194
  field->reset();
201
 
  if (field == field->getTable()->next_number_field)
 
195
  if (field == field->table->next_number_field)
202
196
  {
203
 
    field->getTable()->auto_increment_field_not_null= false;
 
197
    field->table->auto_increment_field_not_null= false;
204
198
    return 0;                             // field is set in fill_record()
205
199
  }
206
 
 
207
 
  if (field->getTable()->in_use->count_cuted_fields == CHECK_FIELD_WARN)
 
200
  if (field->table->in_use->count_cuted_fields == CHECK_FIELD_WARN)
208
201
  {
209
202
    field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_BAD_NULL_ERROR, 1);
210
203
    return 0;
211
204
  }
212
 
 
213
 
  if (!field->getTable()->in_use->no_errors)
 
205
  if (!field->table->in_use->no_errors)
214
206
    my_error(ER_BAD_NULL_ERROR, MYF(0), field->field_name);
215
 
 
216
207
  return -1;
217
208
}
218
209
 
255
246
 
256
247
static void do_copy_not_null(CopyField *copy)
257
248
{
258
 
  if (copy->to_field->hasDefault() and *copy->from_null_ptr & copy->from_bit)
259
 
  {
260
 
    copy->to_field->set_default();
261
 
  }
262
 
  else if (*copy->from_null_ptr & copy->from_bit)
 
249
  if (*copy->from_null_ptr & copy->from_bit)
263
250
  {
264
251
    copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
265
252
                                ER_WARN_DATA_TRUNCATED, 1);
266
253
    copy->to_field->reset();
267
254
  }
268
255
  else
269
 
  {
270
256
    (copy->do_copy2)(copy);
271
 
  }
272
257
}
273
258
 
274
259
 
285
270
  if (*copy->from_null_ptr & copy->from_bit)
286
271
  {
287
272
    /* Same as in set_field_to_null_with_conversions() */
288
 
    ((field::Epoch::pointer) copy->to_field)->set_time();
 
273
    ((Field_timestamp*) copy->to_field)->set_time();
289
274
  }
290
275
  else
291
 
  {
292
276
    (copy->do_copy2)(copy);
293
 
  }
294
277
}
295
278
 
296
279
 
299
282
  if (*copy->from_null_ptr & copy->from_bit)
300
283
  {
301
284
    /* Same as in set_field_to_null_with_conversions() */
302
 
    copy->to_field->getTable()->auto_increment_field_not_null= false;
 
285
    copy->to_field->table->auto_increment_field_not_null= false;
303
286
    copy->to_field->reset();
304
287
  }
305
288
  else
306
 
  {
307
289
    (copy->do_copy2)(copy);
308
 
  }
309
290
}
310
291
 
311
292
 
318
299
 
319
300
static void do_conv_blob(CopyField *copy)
320
301
{
321
 
  copy->from_field->val_str_internal(&copy->tmp);
 
302
  copy->from_field->val_str(&copy->tmp);
322
303
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
323
304
                                         copy->tmp.length(),
324
305
                                         copy->tmp.charset());
330
311
{
331
312
  char buff[MAX_FIELD_WIDTH];
332
313
  String res(buff, sizeof(buff), copy->tmp.charset());
333
 
  copy->from_field->val_str_internal(&res);
 
314
  copy->from_field->val_str(&res);
334
315
  copy->tmp.copy(res);
335
316
  ((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
336
317
                                         copy->tmp.length(),
342
323
{
343
324
  char buff[MAX_FIELD_WIDTH];
344
325
  copy->tmp.set_quick(buff,sizeof(buff),copy->tmp.charset());
345
 
  copy->from_field->val_str_internal(&copy->tmp);
 
326
  copy->from_field->val_str(&copy->tmp);
346
327
  copy->to_field->store(copy->tmp.c_ptr_quick(),copy->tmp.length(),
347
328
                        copy->tmp.charset());
348
329
}
373
354
 
374
355
static void do_field_decimal(CopyField *copy)
375
356
{
376
 
  type::Decimal value;
 
357
  my_decimal value;
377
358
  copy->to_field->store_decimal(copy->from_field->val_decimal(&value));
378
359
}
379
360
 
386
367
static void do_cut_string(CopyField *copy)
387
368
{
388
369
  const CHARSET_INFO * const cs= copy->from_field->charset();
389
 
  memcpy(copy->to_ptr, copy->from_ptr, copy->to_length);
 
370
  memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
390
371
 
391
372
  /* Check if we loosed any important characters */
392
373
  if (cs->cset->scan(cs,
462
443
  if (length > copy->to_length- 1)
463
444
  {
464
445
    length= copy->to_length - 1;
465
 
    if (copy->from_field->getTable()->in_use->count_cuted_fields)
466
 
    {
 
446
    if (copy->from_field->table->in_use->count_cuted_fields)
467
447
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
468
448
                                  ER_WARN_DATA_TRUNCATED, 1);
469
 
    }
470
449
  }
471
450
  *(unsigned char*) copy->to_ptr= (unsigned char) length;
472
451
  memcpy(copy->to_ptr+1, copy->from_ptr + 1, length);
486
465
  if (length < from_length)
487
466
  {
488
467
    if (current_session->count_cuted_fields)
489
 
    {
490
468
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
491
469
                                  ER_WARN_DATA_TRUNCATED, 1);
492
 
    }
493
470
  }
494
471
  *copy->to_ptr= (unsigned char) length;
495
472
  memcpy(copy->to_ptr + 1, from_ptr, length);
502
479
  if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
503
480
  {
504
481
    length=copy->to_length-HA_KEY_BLOB_LENGTH;
505
 
    if (copy->from_field->getTable()->in_use->count_cuted_fields)
506
 
    {
 
482
    if (copy->from_field->table->in_use->count_cuted_fields)
507
483
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
508
484
                                  ER_WARN_DATA_TRUNCATED, 1);
509
 
    }
510
485
  }
511
486
  int2store(copy->to_ptr,length);
512
487
  memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, copy->from_ptr + HA_KEY_BLOB_LENGTH,
527
502
  if (length < from_length)
528
503
  {
529
504
    if (current_session->count_cuted_fields)
530
 
    {
531
505
      copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
532
506
                                  ER_WARN_DATA_TRUNCATED, 1);
533
 
    }
534
507
  }
535
508
  int2store(copy->to_ptr, length);
536
509
  memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, from_beg, length);
561
534
    to_ptr[0]= 1;                             // Null as default value
562
535
    to_null_ptr= (unsigned char*) to_ptr++;
563
536
    to_bit= 1;
564
 
    if (from->getTable()->maybe_null)
 
537
    if (from->table->maybe_null)
565
538
    {
566
 
      null_row= &from->getTable()->null_row;
 
539
      null_row= &from->table->null_row;
567
540
      do_copy= do_outer_field_to_null_str;
568
541
    }
569
542
    else
619
592
      to_null_ptr= to->null_ptr;
620
593
      to_bit= to->null_bit;
621
594
      if (from_null_ptr)
622
 
      {
623
595
        do_copy= do_copy_null;
624
 
      }
625
596
      else
626
597
      {
627
 
        null_row= &from->getTable()->null_row;
 
598
        null_row= &from->table->null_row;
628
599
        do_copy= do_outer_field_null;
629
600
      }
630
601
    }
631
602
    else
632
603
    {
633
 
      if (to_field->is_timestamp())
634
 
      {
 
604
      if (to_field->type() == DRIZZLE_TYPE_TIMESTAMP)
635
605
        do_copy= do_copy_timestamp;               // Automatic timestamp
636
 
      }
637
 
      else if (to_field == to_field->getTable()->next_number_field)
638
 
      {
 
606
      else if (to_field == to_field->table->next_number_field)
639
607
        do_copy= do_copy_next_number;
640
 
      }
641
608
      else
642
 
      {
643
609
        do_copy= do_copy_not_null;
644
 
      }
645
610
    }
646
611
  }
647
612
  else if (to_field->real_maybe_null())
665
630
CopyField::Copy_func *
666
631
CopyField::get_copy_func(Field *to,Field *from)
667
632
{
668
 
  bool compatible_db_low_byte_first= (to->getTable()->getShare()->db_low_byte_first ==
669
 
                                     from->getTable()->getShare()->db_low_byte_first);
 
633
  bool compatible_db_low_byte_first= (to->table->s->db_low_byte_first ==
 
634
                                     from->table->s->db_low_byte_first);
670
635
  if (to->flags & BLOB_FLAG)
671
636
  {
672
637
    if (!(from->flags & BLOB_FLAG) || from->charset() != to->charset())
674
639
    if (from_length != to_length || !compatible_db_low_byte_first)
675
640
    {
676
641
      // Correct pointer to point at char pointer
677
 
      to_ptr+= to_length - to->getTable()->getShare()->sizeBlobPtr();
678
 
      from_ptr+= from_length- from->getTable()->getShare()->sizeBlobPtr();
 
642
      to_ptr+= to_length - to->table->s->blob_ptr_size;
 
643
      from_ptr+= from_length- from->table->s->blob_ptr_size;
679
644
      return do_copy_blob;
680
645
    }
681
646
  }
693
658
      */
694
659
      if (to->real_type() != from->real_type() ||
695
660
          !compatible_db_low_byte_first ||
696
 
          (((to->getTable()->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) && to->type() == DRIZZLE_TYPE_DATE) || to->type() == DRIZZLE_TYPE_DATETIME))
 
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))
697
662
      {
698
663
        if (from->real_type() == DRIZZLE_TYPE_ENUM)
699
664
        {
701
666
          {
702
667
            return do_field_int;  // Convert SET to number
703
668
          }
704
 
 
 
669
          
705
670
          return do_field_string;
706
671
        }
707
672
      }
708
 
 
 
673
      
709
674
      if (to->real_type() == DRIZZLE_TYPE_ENUM)
710
675
      {
711
676
        if (!to->eq_def(from))
721
686
        return do_field_string;
722
687
      else if (to->real_type() == DRIZZLE_TYPE_VARCHAR)
723
688
      {
724
 
        /* Field_blob is not part of the Field_varstring hierarchy,
725
 
          and casting to varstring for calling pack_length_no_ptr()
726
 
          is always incorrect. Previously the below comparison has
727
 
          always evaluated to false as pack_length_no_ptr() for BLOB
728
 
          will return 4 and varstring can only be <= 2.
729
 
          If your brain slightly bleeds as to why this worked for
730
 
          so many years, you are in no way alone.
731
 
        */
732
 
        if (from->flags & BLOB_FLAG)
733
 
          return do_field_string;
734
 
 
735
 
        if ((static_cast<Field_varstring*>(to))->pack_length_no_ptr() !=
736
 
            (static_cast<Field_varstring*>(from))->pack_length_no_ptr())
 
689
        if (((Field_varstring*) to)->length_bytes !=
 
690
            ((Field_varstring*) from)->length_bytes)
737
691
        {
738
692
          return do_field_string;
739
693
        }
740
 
 
 
694
        
741
695
        if (to_length != from_length)
742
696
        {
743
 
          return (((Field_varstring*) to)->pack_length_no_ptr() == 1 ?
 
697
          return (((Field_varstring*) to)->length_bytes == 1 ?
744
698
                  (from->charset()->mbmaxlen == 1 ? do_varstring1 :
745
 
                   do_varstring1_mb) :
 
699
                                                    do_varstring1_mb) :
746
700
                  (from->charset()->mbmaxlen == 1 ? do_varstring2 :
747
 
                   do_varstring2_mb));
 
701
                                                    do_varstring2_mb));
748
702
        }
749
703
      }
750
704
      else if (to_length < from_length)
803
757
int field_conv(Field *to,Field *from)
804
758
{
805
759
  if (to->real_type() == from->real_type() &&
806
 
      !(to->type() == DRIZZLE_TYPE_BLOB && to->getTable()->copy_blobs))
 
760
      !(to->type() == DRIZZLE_TYPE_BLOB && to->table->copy_blobs))
807
761
  {
808
762
    /* Please god, will someone rewrite this to be readable :( */
809
763
    if (to->pack_length() == from->pack_length() &&
811
765
        to->real_type() != DRIZZLE_TYPE_ENUM &&
812
766
        (to->real_type() != DRIZZLE_TYPE_DECIMAL || (to->field_length == from->field_length && (((Field_num*)to)->dec == ((Field_num*)from)->dec))) &&
813
767
        from->charset() == to->charset() &&
814
 
        to->getTable()->getShare()->db_low_byte_first == from->getTable()->getShare()->db_low_byte_first &&
815
 
        (!(to->getTable()->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) || (to->type() != DRIZZLE_TYPE_DATE && to->type() != DRIZZLE_TYPE_DATETIME)) &&
816
 
        (from->real_type() != DRIZZLE_TYPE_VARCHAR || ((Field_varstring*)from)->pack_length_no_ptr() == ((Field_varstring*)to)->pack_length_no_ptr()))
 
768
        to->table->s->db_low_byte_first == from->table->s->db_low_byte_first &&
 
769
        (!(to->table->in_use->variables.sql_mode & (MODE_NO_ZERO_DATE | MODE_INVALID_DATES)) || (to->type() != DRIZZLE_TYPE_DATE && to->type() != DRIZZLE_TYPE_DATETIME)) &&
 
770
        (from->real_type() != DRIZZLE_TYPE_VARCHAR || ((Field_varstring*)from)->length_bytes == ((Field_varstring*)to)->length_bytes))
817
771
    {                                           // Identical fields
818
772
      /* This may happen if one does 'UPDATE ... SET x=x' */
819
773
      if (to->ptr != from->ptr)
824
778
  if (to->type() == DRIZZLE_TYPE_BLOB)
825
779
  {                                             // Be sure the value is stored
826
780
    Field_blob *blob=(Field_blob*) to;
827
 
    from->val_str_internal(&blob->value);
 
781
    from->val_str(&blob->value);
828
782
    /*
829
783
      Copy value if copy_blobs is set, or source is not a string and
830
784
      we have a pointer to its internal string conversion buffer.
831
785
    */
832
 
    if (to->getTable()->copy_blobs ||
 
786
    if (to->table->copy_blobs ||
833
787
        (!blob->value.is_alloced() &&
834
788
         from->real_type() != DRIZZLE_TYPE_VARCHAR))
835
789
      blob->value.copy();
848
802
  {
849
803
    char buff[MAX_FIELD_WIDTH];
850
804
    String result(buff,sizeof(buff),from->charset());
851
 
    from->val_str_internal(&result);
 
805
    from->val_str(&result);
852
806
    /*
853
807
      We use c_ptr_quick() here to make it easier if to is a float/double
854
808
      as the conversion routines will do a copy of the result doesn't
858
812
    return to->store(result.c_ptr_quick(),result.length(),from->charset());
859
813
  }
860
814
  else if (from->result_type() == REAL_RESULT)
861
 
  {
862
815
    return to->store(from->val_real());
863
 
  }
864
816
  else if (from->result_type() == DECIMAL_RESULT)
865
817
  {
866
 
    type::Decimal buff;
 
818
    my_decimal buff;
867
819
    return to->store_decimal(from->val_decimal(&buff));
868
820
  }
869
821
  else
870
 
  {
871
822
    return to->store(from->val_int(), test(from->flags & UNSIGNED_FLAG));
872
 
  }
873
823
}
874
 
 
875
 
} /* namespace drizzled */