← 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-11-06 15:43:10 UTC
  • mfrom: (1908.1.1 merge)
  • Revision ID: brian@tangent.org-20101106154310-g1jpjzwbc53pfc4f
Filesort encapsulation, plus modification to copy contructor

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/filesort.cc
328
328
    goto err;
329
329
  }
330
330
 
331
 
  if (buffpek_pointers.open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
 
331
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir.c_str(),TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
332
332
  {
333
333
    goto err;
334
334
  }
365
365
    }
366
366
    buffpek_inst= (buffpek *) table_sort.buffpek;
367
367
    table_sort.buffpek_len= maxbuffer;
368
 
    buffpek_pointers.close_cached_file();
 
368
    close_cached_file(&buffpek_pointers);
369
369
        /* Open cached file if it isn't open */
370
 
    if (! my_b_inited(outfile) && outfile->open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER, MYF(MY_WME)))
 
370
    if (! my_b_inited(outfile) && open_cached_file(outfile,drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER, MYF(MY_WME)))
371
371
    {
372
372
      goto err;
373
373
    }
374
374
 
375
 
    if (outfile->reinit_io_cache(internal::WRITE_CACHE,0L,0,0))
 
375
    if (reinit_io_cache(outfile,internal::WRITE_CACHE,0L,0,0))
376
376
    {
377
377
      goto err;
378
378
    }
389
389
      goto err;
390
390
    }
391
391
 
392
 
    if (flush_io_cache(&tempfile) || tempfile.reinit_io_cache(internal::READ_CACHE,0L,0,0))
 
392
    if (flush_io_cache(&tempfile) || reinit_io_cache(&tempfile,internal::READ_CACHE,0L,0,0))
393
393
    {
394
394
      goto err;
395
395
    }
416
416
    table_sort.buffpek_len= 0;
417
417
  }
418
418
 
419
 
  tempfile.close_cached_file();
420
 
  buffpek_pointers.close_cached_file();
 
419
  close_cached_file(&tempfile);
 
420
  close_cached_file(&buffpek_pointers);
421
421
  if (my_b_inited(outfile))
422
422
  {
423
423
    if (flush_io_cache(outfile))
427
427
    {
428
428
      internal::my_off_t save_pos=outfile->pos_in_file;
429
429
      /* For following reads */
430
 
      if (outfile->reinit_io_cache(internal::READ_CACHE,0L,0,0))
 
430
      if (reinit_io_cache(outfile,internal::READ_CACHE,0L,0,0))
431
431
      {
432
432
        error=1;
433
433
      }
482
482
    tmp= (unsigned char *)malloc(length);
483
483
  if (tmp)
484
484
  {
485
 
    if (buffpek_pointers->reinit_io_cache(internal::READ_CACHE,0L,0,0) ||
 
485
    if (reinit_io_cache(buffpek_pointers,internal::READ_CACHE,0L,0,0) ||
486
486
        my_b_read(buffpek_pointers, (unsigned char*) tmp, length))
487
487
    {
488
488
      free((char*) tmp);
541
541
  unsigned char *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];
542
542
  internal::my_off_t record;
543
543
  Table *sort_form;
544
 
  volatile Session::killed_state_t *killed= getSession().getKilledPtr();
 
544
  volatile Session::killed_state *killed= &getSession().killed;
545
545
  Cursor *file;
546
546
  boost::dynamic_bitset<> *save_read_set= NULL;
547
547
  boost::dynamic_bitset<> *save_write_set= NULL;
721
721
 
722
722
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
723
723
  if (!my_b_inited(tempfile) &&
724
 
      tempfile->open_cached_file(drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
 
724
      open_cached_file(tempfile, drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
725
725
  {
726
726
    return 1;
727
727
  }
1082
1082
  if (*maxbuffer < MERGEBUFF2)
1083
1083
    return 0;
1084
1084
  if (flush_io_cache(t_file) ||
1085
 
      t_file2.open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE, MYF(MY_WME)))
 
1085
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE, MYF(MY_WME)))
1086
1086
  {
1087
1087
    return 1;
1088
1088
  }
1092
1092
  {
1093
1093
    register uint32_t i;
1094
1094
 
1095
 
    if (from_file->reinit_io_cache(internal::READ_CACHE,0L,0,0))
 
1095
    if (reinit_io_cache(from_file,internal::READ_CACHE,0L,0,0))
1096
1096
    {
1097
1097
      break;
1098
1098
    }
1099
1099
 
1100
 
    if (to_file->reinit_io_cache(internal::WRITE_CACHE,0L,0,0))
 
1100
    if (reinit_io_cache(to_file,internal::WRITE_CACHE,0L,0,0))
1101
1101
    {
1102
1102
      break;
1103
1103
    }
1124
1124
    }
1125
1125
 
1126
1126
    temp=from_file; from_file=to_file; to_file=temp;
1127
 
    from_file->setup_io_cache();
1128
 
    to_file->setup_io_cache();
 
1127
    setup_io_cache(from_file);
 
1128
    setup_io_cache(to_file);
1129
1129
    *maxbuffer= (uint32_t) (lastbuff-buffpek_inst)-1;
1130
1130
  }
1131
1131
 
1132
1132
cleanup:
1133
 
  to_file->close_cached_file();                 // This holds old result
 
1133
  close_cached_file(to_file);                   // This holds old result
1134
1134
  if (to_file == t_file)
1135
1135
  {
1136
1136
    *t_file=t_file2;                            // Copy result file
1137
 
    t_file->setup_io_cache();
 
1137
    setup_io_cache(t_file);
1138
1138
  }
1139
1139
 
1140
1140
  return(*maxbuffer >= MERGEBUFF2);     /* Return 1 if interrupted */
1216
1216
  buffpek *buffpek_inst;
1217
1217
  qsort2_cmp cmp;
1218
1218
  void *first_cmp_arg;
1219
 
  volatile Session::killed_state_t *killed= getSession().getKilledPtr();
1220
 
  Session::killed_state_t not_killable;
 
1219
  volatile Session::killed_state *killed= &getSession().killed;
 
1220
  Session::killed_state not_killable;
1221
1221
 
1222
1222
  getSession().status_var.filesort_merge_passes++;
1223
1223
  if (param->not_killable)