← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Barry.Leslie at PrimeBase
  • Date: 2011-01-22 03:22:44 UTC
  • mfrom: (2101 staging)
  • mto: (2228.1.4 build)
  • mto: This revision was merged to the branch mainline in revision 2230.
  • Revision ID: barry.leslie@primebase.com-20110122032244-ukbe3mlj7fs8xph6
Merged with lp:drizzle.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/filesort.cc
28
28
 
29
29
#include <queue>
30
30
#include <algorithm>
 
31
#include <iostream>
31
32
 
32
33
#include "drizzled/drizzled.h"
33
34
#include "drizzled/sql_sort.h"
52
53
namespace drizzled
53
54
{
54
55
 
55
 
 
56
56
/* Defines used by filesort and uniques */
57
57
#define MERGEBUFF               7
58
58
#define MERGEBUFF2              15
381
381
      Use also the space previously used by string pointers in sort_buffer
382
382
      for temporary key storage.
383
383
    */
384
 
    param.keys=((param.keys*(param.rec_length+sizeof(char*))) /
385
 
                param.rec_length-1);
 
384
    param.keys=((param.keys*(param.rec_length+sizeof(char*))) / param.rec_length-1);
 
385
 
386
386
    maxbuffer--;                                // Offset from 0
387
387
    if (merge_many_buff(&param,(unsigned char*) sort_keys,buffpek_inst,&maxbuffer, &tempfile))
388
388
    {
418
418
 
419
419
  tempfile.close_cached_file();
420
420
  buffpek_pointers.close_cached_file();
 
421
 
421
422
  if (my_b_inited(outfile))
422
423
  {
423
424
    if (flush_io_cache(outfile))
425
426
      error=1;
426
427
    }
427
428
    {
428
 
      internal::my_off_t save_pos=outfile->pos_in_file;
 
429
      internal::my_off_t save_pos= outfile->pos_in_file;
429
430
      /* For following reads */
430
431
      if (outfile->reinit_io_cache(internal::READ_CACHE,0L,0,0))
431
432
      {
434
435
      outfile->end_of_file=save_pos;
435
436
    }
436
437
  }
 
438
 
437
439
  if (error)
438
440
  {
439
441
    my_message(ER_FILSORT_ABORT, ER(ER_FILSORT_ABORT),
562
564
  if (! indexfile && ! quick_select)
563
565
  {
564
566
    next_pos=(unsigned char*) 0;                        /* Find records in sequence */
565
 
    file->startTableScan(1);
 
567
    if (file->startTableScan(1))
 
568
      return(HA_POS_ERROR);
566
569
    file->extra_opt(HA_EXTRA_CACHE, getSession().variables.read_buff_size);
567
570
  }
568
571
 
572
575
    if (select->quick->reset())
573
576
      return(HA_POS_ERROR);
574
577
 
575
 
    read_record_info.init_read_record(&getSession(), select->quick->head, select, 1, 1);
 
578
    if (read_record_info.init_read_record(&getSession(), select->quick->head, select, 1, 1))
 
579
      return(HA_POS_ERROR);
576
580
  }
577
581
 
578
582
  /* Remember original bitmaps */
683
687
    sort_form->print_error(error,MYF(ME_ERROR | ME_WAITTANG));
684
688
    return(HA_POS_ERROR);
685
689
  }
686
 
  if (indexpos && idx &&
687
 
      param->write_keys(sort_keys,idx,buffpek_pointers,tempfile))
 
690
 
 
691
  if (indexpos && idx && param->write_keys(sort_keys,idx,buffpek_pointers,tempfile))
 
692
  {
688
693
    return(HA_POS_ERROR);
 
694
  }
 
695
 
689
696
  return(my_b_inited(tempfile) ?
690
697
              (ha_rows) (my_b_tell(tempfile)/param->rec_length) :
691
698
              idx);
812
819
    {                                           // Item
813
820
      Item *item=sort_field->item;
814
821
      maybe_null= item->maybe_null;
 
822
 
815
823
      switch (sort_field->result_type) {
816
824
      case STRING_RESULT:
817
 
      {
818
 
        const CHARSET_INFO * const cs=item->collation.collation;
819
 
        char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');
820
 
        int diff;
821
 
        uint32_t sort_field_length;
 
825
        {
 
826
          const CHARSET_INFO * const cs=item->collation.collation;
 
827
          char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');
 
828
          int diff;
 
829
          uint32_t sort_field_length;
822
830
 
823
 
        if (maybe_null)
824
 
          *to++=1;
825
 
        /* All item->str() to use some extra byte for end null.. */
826
 
        String tmp((char*) to,sort_field->length+4,cs);
827
 
        String *res= item->str_result(&tmp);
828
 
        if (!res)
829
 
        {
830
831
          if (maybe_null)
831
 
            memset(to-1, 0, sort_field->length+1);
 
832
            *to++=1;
 
833
          /* All item->str() to use some extra byte for end null.. */
 
834
          String tmp((char*) to,sort_field->length+4,cs);
 
835
          String *res= item->str_result(&tmp);
 
836
          if (!res)
 
837
          {
 
838
            if (maybe_null)
 
839
              memset(to-1, 0, sort_field->length+1);
 
840
            else
 
841
            {
 
842
              /*
 
843
                This should only happen during extreme conditions if we run out
 
844
                of memory or have an item marked not null when it can be null.
 
845
                This code is here mainly to avoid a hard crash in this case.
 
846
              */
 
847
              assert(0);
 
848
              memset(to, 0, sort_field->length);        // Avoid crash
 
849
            }
 
850
            break;
 
851
          }
 
852
          length= res->length();
 
853
          sort_field_length= sort_field->length - sort_field->suffix_length;
 
854
          diff=(int) (sort_field_length - length);
 
855
          if (diff < 0)
 
856
          {
 
857
            diff=0;
 
858
            length= sort_field_length;
 
859
          }
 
860
          if (sort_field->suffix_length)
 
861
          {
 
862
            /* Store length last in result_string */
 
863
            store_length(to + sort_field_length, length,
 
864
                         sort_field->suffix_length);
 
865
          }
 
866
          if (sort_field->need_strxnfrm)
 
867
          {
 
868
            char *from=(char*) res->ptr();
 
869
            uint32_t tmp_length;
 
870
            if ((unsigned char*) from == to)
 
871
            {
 
872
              set_if_smaller(length,sort_field->length);
 
873
              memcpy(tmp_buffer,from,length);
 
874
              from= tmp_buffer;
 
875
            }
 
876
            tmp_length= my_strnxfrm(cs,to,sort_field->length,
 
877
                                    (unsigned char*) from, length);
 
878
            assert(tmp_length == sort_field->length);
 
879
          }
832
880
          else
833
881
          {
834
 
            /*
835
 
              This should only happen during extreme conditions if we run out
836
 
              of memory or have an item marked not null when it can be null.
837
 
              This code is here mainly to avoid a hard crash in this case.
838
 
            */
839
 
            assert(0);
840
 
            memset(to, 0, sort_field->length);  // Avoid crash
 
882
            my_strnxfrm(cs,(unsigned char*)to,length,(const unsigned char*)res->ptr(),length);
 
883
            cs->cset->fill(cs, (char *)to+length,diff,fill_char);
841
884
          }
842
885
          break;
843
886
        }
844
 
        length= res->length();
845
 
        sort_field_length= sort_field->length - sort_field->suffix_length;
846
 
        diff=(int) (sort_field_length - length);
847
 
        if (diff < 0)
848
 
        {
849
 
          diff=0;
850
 
          length= sort_field_length;
851
 
        }
852
 
        if (sort_field->suffix_length)
853
 
        {
854
 
          /* Store length last in result_string */
855
 
          store_length(to + sort_field_length, length,
856
 
                       sort_field->suffix_length);
857
 
        }
858
 
        if (sort_field->need_strxnfrm)
859
 
        {
860
 
          char *from=(char*) res->ptr();
861
 
          uint32_t tmp_length;
862
 
          if ((unsigned char*) from == to)
863
 
          {
864
 
            set_if_smaller(length,sort_field->length);
865
 
            memcpy(tmp_buffer,from,length);
866
 
            from= tmp_buffer;
867
 
          }
868
 
          tmp_length= my_strnxfrm(cs,to,sort_field->length,
869
 
                                  (unsigned char*) from, length);
870
 
          assert(tmp_length == sort_field->length);
871
 
        }
872
 
        else
873
 
        {
874
 
          my_strnxfrm(cs,(unsigned char*)to,length,(const unsigned char*)res->ptr(),length);
875
 
          cs->cset->fill(cs, (char *)to+length,diff,fill_char);
876
 
        }
877
 
        break;
878
 
      }
879
887
      case INT_RESULT:
880
 
        {
 
888
        {
881
889
          int64_t value= item->val_int_result();
882
890
          if (maybe_null)
883
891
          {
884
 
            *to++=1;
 
892
            *to++=1;
885
893
            if (item->null_value)
886
894
            {
887
895
              if (maybe_null)
893
901
              break;
894
902
            }
895
903
          }
896
 
          to[7]= (unsigned char) value;
897
 
          to[6]= (unsigned char) (value >> 8);
898
 
          to[5]= (unsigned char) (value >> 16);
899
 
          to[4]= (unsigned char) (value >> 24);
900
 
          to[3]= (unsigned char) (value >> 32);
901
 
          to[2]= (unsigned char) (value >> 40);
902
 
          to[1]= (unsigned char) (value >> 48);
 
904
          to[7]= (unsigned char) value;
 
905
          to[6]= (unsigned char) (value >> 8);
 
906
          to[5]= (unsigned char) (value >> 16);
 
907
          to[4]= (unsigned char) (value >> 24);
 
908
          to[3]= (unsigned char) (value >> 32);
 
909
          to[2]= (unsigned char) (value >> 40);
 
910
          to[1]= (unsigned char) (value >> 48);
903
911
          if (item->unsigned_flag)                    /* Fix sign */
904
912
            to[0]= (unsigned char) (value >> 56);
905
913
          else
906
914
            to[0]= (unsigned char) (value >> 56) ^ 128; /* Reverse signbit */
907
 
          break;
908
 
        }
 
915
          break;
 
916
        }
909
917
      case DECIMAL_RESULT:
910
918
        {
911
 
          my_decimal dec_buf, *dec_val= item->val_decimal_result(&dec_buf);
 
919
          type::Decimal dec_buf, *dec_val= item->val_decimal_result(&dec_buf);
912
920
          if (maybe_null)
913
921
          {
914
922
            if (item->null_value)
919
927
            }
920
928
            *to++=1;
921
929
          }
922
 
          my_decimal2binary(E_DEC_FATAL_ERROR, dec_val, to,
923
 
                            item->max_length - (item->decimals ? 1:0),
924
 
                            item->decimals);
925
 
         break;
 
930
          dec_val->val_binary(E_DEC_FATAL_ERROR, to,
 
931
                              item->max_length - (item->decimals ? 1:0),
 
932
                              item->decimals);
 
933
          break;
926
934
        }
927
935
      case REAL_RESULT:
928
 
        {
 
936
        {
929
937
          double value= item->val_result();
930
 
          if (maybe_null)
 
938
          if (maybe_null)
931
939
          {
932
940
            if (item->null_value)
933
941
            {
935
943
              to++;
936
944
              break;
937
945
            }
938
 
            *to++=1;
 
946
            *to++=1;
939
947
          }
940
 
          change_double_for_sort(value,(unsigned char*) to);
941
 
          break;
942
 
        }
 
948
          change_double_for_sort(value,(unsigned char*) to);
 
949
          break;
 
950
        }
943
951
      case ROW_RESULT:
944
952
      default:
945
 
        // This case should never be choosen
946
 
        assert(0);
947
 
        break;
 
953
        // This case should never be choosen
 
954
        assert(0);
 
955
        break;
948
956
      }
949
957
    }
 
958
 
950
959
    if (sort_field->reverse)
951
960
    {                                                   /* Revers key */
952
961
      if (maybe_null)
959
968
      }
960
969
    }
961
970
    else
 
971
    {
962
972
      to+= sort_field->length;
 
973
    }
963
974
  }
964
975
 
965
976
  if (addon_field)
1024
1035
    if ((field= sort_field->field))
1025
1036
    {
1026
1037
      if (field->getTable() == table)
1027
 
        table->setReadSet(field->field_index);
 
1038
        table->setReadSet(field->position());
1028
1039
    }
1029
1040
    else
1030
1041
    {                                           // Item
1038
1049
    sort_addon_field *addonf= addon_field;
1039
1050
    Field *field;
1040
1051
    for ( ; (field= addonf->field) ; addonf++)
1041
 
      table->setReadSet(field->field_index);
 
1052
      table->setReadSet(field->position());
1042
1053
  }
1043
1054
  else
1044
1055
  {
1048
1059
}
1049
1060
 
1050
1061
 
1051
 
bool SortParam::save_index(unsigned char **sort_keys, uint32_t count,
1052
 
                           filesort_info *table_sort)
 
1062
bool SortParam::save_index(unsigned char **sort_keys, uint32_t count, filesort_info *table_sort)
1053
1063
{
1054
1064
  uint32_t offset;
1055
1065
  unsigned char *to;
1056
1066
 
1057
1067
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
1058
1068
  offset= rec_length - res_length;
 
1069
 
1059
1070
  if ((ha_rows) count > max_rows)
1060
1071
    count=(uint32_t) max_rows;
1061
 
  if (!(to= table_sort->record_pointers=
1062
 
        (unsigned char*) malloc(res_length*count)))
 
1072
 
 
1073
  if (!(to= table_sort->record_pointers= (unsigned char*) malloc(res_length*count)))
1063
1074
    return true;
1064
1075
 
1065
1076
  for (unsigned char **end_ptr= sort_keys+count ; sort_keys != end_ptr ; sort_keys++)
1067
1078
    memcpy(to, *sort_keys+offset, res_length);
1068
1079
    to+= res_length;
1069
1080
  }
 
1081
 
1070
1082
  return false;
1071
1083
}
1072
1084
 
1171
1183
{
1172
1184
  qsort2_cmp key_compare;
1173
1185
  void *key_compare_arg;
 
1186
 
1174
1187
  public:
1175
 
  compare_functor(qsort2_cmp in_key_compare, void *in_compare_arg)
1176
 
    : key_compare(in_key_compare), key_compare_arg(in_compare_arg) { }
 
1188
  compare_functor(qsort2_cmp in_key_compare, void *in_compare_arg) :
 
1189
    key_compare(in_key_compare),
 
1190
    key_compare_arg(in_compare_arg)
 
1191
  { }
 
1192
  
1177
1193
  inline bool operator()(const buffpek *i, const buffpek *j) const
1178
1194
  {
1179
 
    int val= key_compare(key_compare_arg,
1180
 
                      &i->key, &j->key);
 
1195
    int val= key_compare(key_compare_arg, &i->key, &j->key);
 
1196
 
1181
1197
    return (val >= 0);
1182
1198
  }
1183
1199
};
1486
1502
      sortorder->result_type= sortorder->item->result_type();
1487
1503
      if (sortorder->item->result_as_int64_t())
1488
1504
        sortorder->result_type= INT_RESULT;
 
1505
 
1489
1506
      switch (sortorder->result_type) {
1490
1507
      case STRING_RESULT:
1491
 
        sortorder->length=sortorder->item->max_length;
 
1508
        sortorder->length=sortorder->item->max_length;
1492
1509
        set_if_smaller(sortorder->length,
1493
1510
                       getSession().variables.max_sort_length);
1494
 
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
1495
 
        {
 
1511
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
 
1512
        {
1496
1513
          sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
1497
 
          sortorder->need_strxnfrm= 1;
1498
 
          *multi_byte_charset= 1;
1499
 
        }
 
1514
          sortorder->need_strxnfrm= 1;
 
1515
          *multi_byte_charset= 1;
 
1516
        }
1500
1517
        else if (cs == &my_charset_bin)
1501
1518
        {
1502
1519
          /* Store length last to be able to sort blob/varbinary */
1503
1520
          sortorder->suffix_length= suffix_length(sortorder->length);
1504
1521
          sortorder->length+= sortorder->suffix_length;
1505
1522
        }
1506
 
        break;
 
1523
        break;
1507
1524
      case INT_RESULT:
1508
 
        sortorder->length=8;                    // Size of intern int64_t
1509
 
        break;
 
1525
        sortorder->length=8;                    // Size of intern int64_t
 
1526
        break;
1510
1527
      case DECIMAL_RESULT:
1511
1528
        sortorder->length=
1512
 
          my_decimal_get_binary_size(sortorder->item->max_length -
 
1529
          class_decimal_get_binary_size(sortorder->item->max_length -
1513
1530
                                     (sortorder->item->decimals ? 1 : 0),
1514
1531
                                     sortorder->item->decimals);
1515
1532
        break;
1516
1533
      case REAL_RESULT:
1517
 
        sortorder->length=sizeof(double);
1518
 
        break;
 
1534
        sortorder->length=sizeof(double);
 
1535
        break;
1519
1536
      case ROW_RESULT:
1520
 
      default:
1521
 
        // This case should never be choosen
1522
 
        assert(0);
1523
 
        break;
 
1537
        // This case should never be choosen
 
1538
        assert(0);
 
1539
        break;
1524
1540
      }
1525
1541
      if (sortorder->item->maybe_null)
1526
 
        length++;                               // Place for NULL marker
 
1542
        length++;                               // Place for NULL marker
1527
1543
    }
1528
1544
    set_if_smaller(sortorder->length, (size_t)getSession().variables.max_sort_length);
1529
1545
    length+=sortorder->length;