← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Brian Aker
  • Date: 2010-12-16 04:01:22 UTC
  • mfrom: (1996.2.1 compare)
  • Revision ID: brian@tangent.org-20101216040122-eodh5shwsij35ybe
Merge in uuid tree.

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),
683
685
    sort_form->print_error(error,MYF(ME_ERROR | ME_WAITTANG));
684
686
    return(HA_POS_ERROR);
685
687
  }
686
 
  if (indexpos && idx &&
687
 
      param->write_keys(sort_keys,idx,buffpek_pointers,tempfile))
 
688
 
 
689
  if (indexpos && idx && param->write_keys(sort_keys,idx,buffpek_pointers,tempfile))
 
690
  {
688
691
    return(HA_POS_ERROR);
 
692
  }
 
693
 
689
694
  return(my_b_inited(tempfile) ?
690
695
              (ha_rows) (my_b_tell(tempfile)/param->rec_length) :
691
696
              idx);
1048
1053
}
1049
1054
 
1050
1055
 
1051
 
bool SortParam::save_index(unsigned char **sort_keys, uint32_t count,
1052
 
                           filesort_info *table_sort)
 
1056
bool SortParam::save_index(unsigned char **sort_keys, uint32_t count, filesort_info *table_sort)
1053
1057
{
1054
1058
  uint32_t offset;
1055
1059
  unsigned char *to;
1056
1060
 
1057
1061
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
1058
1062
  offset= rec_length - res_length;
 
1063
 
1059
1064
  if ((ha_rows) count > max_rows)
1060
1065
    count=(uint32_t) max_rows;
1061
 
  if (!(to= table_sort->record_pointers=
1062
 
        (unsigned char*) malloc(res_length*count)))
 
1066
 
 
1067
  if (!(to= table_sort->record_pointers= (unsigned char*) malloc(res_length*count)))
1063
1068
    return true;
1064
1069
 
1065
1070
  for (unsigned char **end_ptr= sort_keys+count ; sort_keys != end_ptr ; sort_keys++)
1067
1072
    memcpy(to, *sort_keys+offset, res_length);
1068
1073
    to+= res_length;
1069
1074
  }
 
1075
 
1070
1076
  return false;
1071
1077
}
1072
1078
 
1171
1177
{
1172
1178
  qsort2_cmp key_compare;
1173
1179
  void *key_compare_arg;
 
1180
 
1174
1181
  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) { }
 
1182
  compare_functor(qsort2_cmp in_key_compare, void *in_compare_arg) :
 
1183
    key_compare(in_key_compare),
 
1184
    key_compare_arg(in_compare_arg)
 
1185
  { }
 
1186
  
1177
1187
  inline bool operator()(const buffpek *i, const buffpek *j) const
1178
1188
  {
1179
 
    int val= key_compare(key_compare_arg,
1180
 
                      &i->key, &j->key);
 
1189
    int val= key_compare(key_compare_arg, &i->key, &j->key);
 
1190
 
1181
1191
    return (val >= 0);
1182
1192
  }
1183
1193
};