← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/sort.c

  • Committer: Brian Aker
  • Date: 2008-07-16 21:28:26 UTC
  • mfrom: (77.3.28 glibclient)
  • Revision ID: brian@tangent.org-20080716212826-p44t3u6v1zb0dmxg
Merge from Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/sort.c
104
104
  ha_rows records;
105
105
  uchar **sort_keys;
106
106
  IO_CACHE tempfile, tempfile_for_exceptions;
107
 
  DBUG_ENTER("_create_index_by_sort");
108
 
  DBUG_PRINT("enter",("sort_length: %d", info->key_length));
109
107
 
110
108
  if (info->keyinfo->flag & HA_VAR_LENGTH_KEY)
111
109
  {
243
241
  close_cached_file(&tempfile);
244
242
  close_cached_file(&tempfile_for_exceptions);
245
243
 
246
 
  DBUG_RETURN(error ? -1 : 0);
 
244
  return(error ? -1 : 0);
247
245
} /* _create_index_by_sort */
248
246
 
249
247
 
256
254
{
257
255
  int error;
258
256
  uint idx;
259
 
  DBUG_ENTER("find_all_keys");
260
257
 
261
258
  idx=error=0;
262
259
  sort_keys[0]=(uchar*) (sort_keys+keys);
266
263
    if (info->real_key_length > info->key_length)
267
264
    {
268
265
      if (write_key(info,sort_keys[idx],tempfile_for_exceptions))
269
 
        DBUG_RETURN(HA_POS_ERROR);              /* purecov: inspected */
 
266
        return(HA_POS_ERROR);           /* purecov: inspected */
270
267
      continue;
271
268
    }
272
269
 
274
271
    {
275
272
      if (info->write_keys(info,sort_keys,idx-1,(BUFFPEK *)alloc_dynamic(buffpek),
276
273
                     tempfile))
277
 
      DBUG_RETURN(HA_POS_ERROR);                /* purecov: inspected */
 
274
      return(HA_POS_ERROR);             /* purecov: inspected */
278
275
 
279
276
      sort_keys[0]=(uchar*) (sort_keys+keys);
280
277
      memcpy(sort_keys[0],sort_keys[idx-1],(size_t) info->key_length);
283
280
    sort_keys[idx]=sort_keys[idx-1]+info->key_length;
284
281
  }
285
282
  if (error > 0)
286
 
    DBUG_RETURN(HA_POS_ERROR);          /* Aborted by get_key */ /* purecov: inspected */
 
283
    return(HA_POS_ERROR);               /* Aborted by get_key */ /* purecov: inspected */
287
284
  if (buffpek->elements)
288
285
  {
289
286
    if (info->write_keys(info,sort_keys,idx,(BUFFPEK *)alloc_dynamic(buffpek),
290
287
                   tempfile))
291
 
      DBUG_RETURN(HA_POS_ERROR);                /* purecov: inspected */
 
288
      return(HA_POS_ERROR);             /* purecov: inspected */
292
289
    *maxbuffer=buffpek->elements-1;
293
290
  }
294
291
  else
295
292
    *maxbuffer=0;
296
293
 
297
 
  DBUG_RETURN((*maxbuffer)*(keys-1)+idx);
 
294
  return((*maxbuffer)*(keys-1)+idx);
298
295
} /* find_all_keys */
299
296
 
300
297
 
313
310
  if (my_thread_init())
314
311
    goto err;
315
312
 
316
 
  { /* Add extra block since DBUG_ENTER declare variables */
317
 
    DBUG_ENTER("thr_find_all_keys");
318
 
    DBUG_PRINT("enter", ("master: %d", sort_param->master));
 
313
  { 
319
314
    if (sort_param->sort_info->got_error)
320
315
      goto err;
321
316
 
398
393
    idx= error= 0;
399
394
    sort_keys[0]= (uchar*) (sort_keys+keys);
400
395
 
401
 
    DBUG_PRINT("info", ("reading keys"));
402
396
    while (!(error= sort_param->sort_info->got_error) &&
403
397
           !(error= (*sort_param->key_read)(sort_param, sort_keys[idx])))
404
398
    {
439
433
    goto ok;
440
434
 
441
435
err:
442
 
    DBUG_PRINT("error", ("got some error"));
443
436
    sort_param->sort_info->got_error= 1; /* no need to protect with a mutex */
444
437
    if (sort_keys)
445
438
      my_free((uchar*) sort_keys,MYF(0));
466
459
    if (!--sort_param->sort_info->threads_running)
467
460
      pthread_cond_signal(&sort_param->sort_info->cond);
468
461
    pthread_mutex_unlock(&sort_param->sort_info->mutex);
469
 
    DBUG_PRINT("exit", ("======== ending thread ========"));
470
462
  }
471
463
  my_thread_end();
472
464
  return NULL;
485
477
  MYISAM_SHARE *share=info->s;
486
478
  MI_SORT_PARAM *sinfo;
487
479
  uchar *mergebuf=0;
488
 
  DBUG_ENTER("thr_write_keys");
489
480
 
490
481
  for (i= 0, sinfo= sort_param ;
491
482
       i < sort_info->total_keys ;
622
613
    }
623
614
  }
624
615
  my_free((uchar*) mergebuf,MYF(MY_ALLOW_ZERO_PTR));
625
 
  DBUG_RETURN(got_error);
 
616
  return(got_error);
626
617
}
627
618
 
628
619
        /* Write all keys in memory to file for later merge */
632
623
{
633
624
  uchar **end;
634
625
  uint sort_length=info->key_length;
635
 
  DBUG_ENTER("write_keys");
636
626
 
637
627
  my_qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp,
638
628
            info);
639
629
  if (!my_b_inited(tempfile) &&
640
630
      open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
641
631
                       DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
642
 
    DBUG_RETURN(1); /* purecov: inspected */
 
632
    return(1); /* purecov: inspected */
643
633
 
644
634
  buffpek->file_pos=my_b_tell(tempfile);
645
635
  buffpek->count=count;
647
637
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
648
638
  {
649
639
    if (my_b_write(tempfile,(uchar*) *sort_keys,(uint) sort_length))
650
 
      DBUG_RETURN(1); /* purecov: inspected */
 
640
      return(1); /* purecov: inspected */
651
641
  }
652
 
  DBUG_RETURN(0);
 
642
  return(0);
653
643
} /* write_keys */
654
644
 
655
645
 
675
665
{
676
666
  uchar **end;
677
667
  int err;
678
 
  DBUG_ENTER("write_keys_varlen");
679
668
 
680
669
  my_qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp,
681
670
            info);
682
671
  if (!my_b_inited(tempfile) &&
683
672
      open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
684
673
                       DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
685
 
    DBUG_RETURN(1); /* purecov: inspected */
 
674
    return(1); /* purecov: inspected */
686
675
 
687
676
  buffpek->file_pos=my_b_tell(tempfile);
688
677
  buffpek->count=count;
689
678
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
690
679
  {
691
680
    if ((err= my_var_write(info,tempfile, (uchar*) *sort_keys)))
692
 
      DBUG_RETURN(err);
 
681
      return(err);
693
682
  }
694
 
  DBUG_RETURN(0);
 
683
  return(0);
695
684
} /* write_keys_varlen */
696
685
 
697
686
 
699
688
                            IO_CACHE *tempfile)
700
689
{
701
690
  uint key_length=info->real_key_length;
702
 
  DBUG_ENTER("write_key");
703
691
 
704
692
  if (!my_b_inited(tempfile) &&
705
693
      open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
706
694
                       DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
707
 
    DBUG_RETURN(1);
 
695
    return(1);
708
696
 
709
697
  if (my_b_write(tempfile,(uchar*)&key_length,sizeof(key_length)) ||
710
698
      my_b_write(tempfile,(uchar*)key,(uint) key_length))
711
 
    DBUG_RETURN(1);
712
 
  DBUG_RETURN(0);
 
699
    return(1);
 
700
  return(0);
713
701
} /* write_key */
714
702
 
715
703
 
718
706
static int  write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
719
707
                              register uint count)
720
708
{
721
 
  DBUG_ENTER("write_index");
722
 
 
723
709
  my_qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*),
724
710
           (qsort2_cmp) info->key_cmp,info);
725
711
  while (count--)
726
712
  {
727
713
    if ((*info->key_write)(info,*sort_keys++))
728
 
      DBUG_RETURN(-1); /* purecov: inspected */
 
714
      return(-1); /* purecov: inspected */
729
715
  }
730
 
  DBUG_RETURN(0);
 
716
  return(0);
731
717
} /* write_index */
732
718
 
733
719
 
740
726
  register int i;
741
727
  IO_CACHE t_file2, *from_file, *to_file, *temp;
742
728
  BUFFPEK *lastbuff;
743
 
  DBUG_ENTER("merge_many_buff");
744
729
 
745
730
  if (*maxbuffer < MERGEBUFF2)
746
 
    DBUG_RETURN(0);                             /* purecov: inspected */
 
731
    return(0);                             /* purecov: inspected */
747
732
  if (flush_io_cache(t_file) ||
748
733
      open_cached_file(&t_file2,my_tmpdir(info->tmpdir),"ST",
749
734
                       DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
750
 
    DBUG_RETURN(1);                             /* purecov: inspected */
 
735
    return(1);                             /* purecov: inspected */
751
736
 
752
737
  from_file= t_file ; to_file= &t_file2;
753
738
  while (*maxbuffer >= MERGEBUFF2)
774
759
  if (to_file == t_file)
775
760
    *t_file=t_file2;                            /* Copy result file */
776
761
 
777
 
  DBUG_RETURN(*maxbuffer >= MERGEBUFF2);        /* Return 1 if interrupted */
 
762
  return(*maxbuffer >= MERGEBUFF2);        /* Return 1 if interrupted */
778
763
} /* merge_many_buff */
779
764
 
780
765
 
885
870
  BUFFPEK *buffpek,**refpek;
886
871
  QUEUE queue;
887
872
  volatile int *killed= killed_ptr(info->sort_info->param);
888
 
  DBUG_ENTER("merge_buffers");
889
873
 
890
874
  count=error=0;
891
875
  maxcount=keys/((uint) (Tb-Fb) +1);
892
 
  DBUG_ASSERT(maxcount > 0);
 
876
  assert(maxcount > 0);
893
877
  if (to_file)
894
878
    to_start_filepos=my_b_tell(to_file);
895
879
  strpos=(uchar*) sort_keys;
898
882
  if (init_queue(&queue,(uint) (Tb-Fb)+1,offsetof(BUFFPEK,key),0,
899
883
                 (int (*)(void*, uchar *,uchar*)) info->key_cmp,
900
884
                 (void*) info))
901
 
    DBUG_RETURN(1); /* purecov: inspected */
 
885
    return(1); /* purecov: inspected */
902
886
 
903
887
  for (buffpek= Fb ; buffpek <= Tb ; buffpek++)
904
888
  {
1008
992
    lastbuff->file_pos=to_start_filepos;
1009
993
err:
1010
994
  delete_queue(&queue);
1011
 
  DBUG_RETURN(error);
 
995
  return(error);
1012
996
} /* merge_buffers */
1013
997
 
1014
998
 
1018
1002
merge_index(MI_SORT_PARAM *info, uint keys, uchar **sort_keys,
1019
1003
            BUFFPEK *buffpek, int maxbuffer, IO_CACHE *tempfile)
1020
1004
{
1021
 
  DBUG_ENTER("merge_index");
1022
1005
  if (merge_buffers(info,keys,tempfile,(IO_CACHE*) 0,sort_keys,buffpek,buffpek,
1023
1006
                    buffpek+maxbuffer))
1024
 
    DBUG_RETURN(1); /* purecov: inspected */
1025
 
  DBUG_RETURN(0);
 
1007
    return(1); /* purecov: inspected */
 
1008
  return(0);
1026
1009
} /* merge_index */
1027
1010