← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/uniques.cc

  • Committer: Jay Pipes
  • Date: 2009-09-21 14:33:44 UTC
  • mfrom: (1126.10.26 dtrace-probes)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: jpipes@serialcoder-20090921143344-jnarp7gcn6zmg19c
Merge fixes from Trond and Padraig on dtrace probes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/uniques.cc
30
30
  deletes in disk order.
31
31
*/
32
32
 
33
 
#include "config.h"
34
 
 
35
 
#include <math.h>
36
 
 
 
33
#include <drizzled/server_includes.h>
 
34
#include <drizzled/sql_sort.h>
 
35
#include <drizzled/session.h>
37
36
#include <queue>
38
37
 
39
 
#include "drizzled/sql_sort.h"
40
 
#include "drizzled/session.h"
41
 
#include "drizzled/sql_list.h"
42
 
#include "drizzled/internal/iocache.h"
43
 
 
44
38
#if defined(CMATH_NAMESPACE)
45
39
using namespace CMATH_NAMESPACE;
46
40
#endif
47
41
 
48
42
using namespace std;
49
43
 
50
 
namespace drizzled
51
 
{
52
44
 
53
 
int unique_write_to_file(unsigned char* key, uint32_t,
 
45
int unique_write_to_file(unsigned char* key, element_count,
54
46
                         Unique *unique)
55
47
{
56
48
  /*
59
51
    when tree implementation chooses to store pointer to key in TREE_ELEMENT
60
52
    (instead of storing the element itself there)
61
53
  */
62
 
  return my_b_write(unique->file, key, unique->size) ? 1 : 0;
 
54
  return my_b_write(&unique->file, key, unique->size) ? 1 : 0;
63
55
}
64
56
 
65
57
int unique_write_to_ptrs(unsigned char* key,
66
 
                         uint32_t, Unique *unique)
 
58
                         element_count, Unique *unique)
67
59
{
68
60
  memcpy(unique->record_pointers, key, unique->size);
69
61
  unique->record_pointers+=unique->size;
72
64
 
73
65
Unique::Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
74
66
               uint32_t size_arg, size_t max_in_memory_size_arg)
75
 
  : max_in_memory_size(max_in_memory_size_arg),
76
 
    file(static_cast<internal::IO_CACHE *>(memory::sql_calloc(sizeof(internal::IO_CACHE)))),
77
 
    size(size_arg),
78
 
    elements(0)
 
67
  :max_in_memory_size(max_in_memory_size_arg), size(size_arg), elements(0)
79
68
{
80
 
  my_b_clear(file);
81
 
  init_tree(&tree, (ulong) (max_in_memory_size / 16), 0, size, comp_func, false,
 
69
  my_b_clear(&file);
 
70
  init_tree(&tree, (ulong) (max_in_memory_size / 16), 0, size, comp_func, 0,
82
71
            NULL, comp_func_fixed_arg);
83
72
  /* If the following fail's the next add will also fail */
84
73
  my_init_dynamic_array(&file_ptrs, sizeof(BUFFPEK), 16, 16);
87
76
  */
88
77
  max_elements= (ulong) (max_in_memory_size /
89
78
                         ALIGN_SIZE(sizeof(TREE_ELEMENT)+size));
90
 
  open_cached_file(file, drizzle_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
 
79
  open_cached_file(&file, drizzle_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
91
80
                   MYF(MY_WME));
92
81
}
93
82
 
331
320
 
332
321
Unique::~Unique()
333
322
{
334
 
  close_cached_file(file);
 
323
  close_cached_file(&file);
335
324
  delete_tree(&tree);
336
325
  delete_dynamic(&file_ptrs);
337
326
}
343
332
  BUFFPEK file_ptr;
344
333
  elements+= tree.elements_in_tree;
345
334
  file_ptr.count=tree.elements_in_tree;
346
 
  file_ptr.file_pos=my_b_tell(file);
 
335
  file_ptr.file_pos=my_b_tell(&file);
347
336
 
348
337
  if (tree_walk(&tree, (tree_walk_action) unique_write_to_file,
349
338
                (void*) this, left_root_right) ||
372
361
  if (elements)
373
362
  {
374
363
    reset_dynamic(&file_ptrs);
375
 
    reinit_io_cache(file, internal::WRITE_CACHE, 0L, 0, 1);
 
364
    reinit_io_cache(&file, WRITE_CACHE, 0L, 0, 1);
376
365
  }
377
366
  elements= 0;
378
367
}
456
445
                       uint32_t key_length, BUFFPEK *begin, BUFFPEK *end,
457
446
                       tree_walk_action walk_action, void *walk_action_arg,
458
447
                       qsort_cmp2 compare, void *compare_arg,
459
 
                       internal::IO_CACHE *file)
 
448
                       IO_CACHE *file)
460
449
{
461
450
  if (end <= begin ||
462
451
      merge_buffer_size < (ulong) (key_length * (end - begin + 1))) 
576
565
  SYNOPSIS
577
566
    Unique:walk()
578
567
  All params are 'IN':
579
 
    action  function-visitor, typed in include/tree.h
 
568
    action  function-visitor, typed in include/my_tree.h
580
569
            function is called for each unique element
581
570
    arg     argument for visitor, which is passed to it on each call
582
571
  RETURN VALUE
595
584
  /* flush current tree to the file to have some memory for merge buffer */
596
585
  if (flush())
597
586
    return 1;
598
 
  if (flush_io_cache(file) || reinit_io_cache(file, internal::READ_CACHE, 0L, 0, 0))
 
587
  if (flush_io_cache(&file) || reinit_io_cache(&file, READ_CACHE, 0L, 0, 0))
599
588
    return 1;
600
589
  if (!(merge_buffer= (unsigned char *) malloc(max_in_memory_size)))
601
590
    return 1;
603
592
                  (BUFFPEK *) file_ptrs.buffer,
604
593
                  (BUFFPEK *) file_ptrs.buffer + file_ptrs.elements,
605
594
                  action, walk_action_arg,
606
 
                  tree.compare, tree.custom_arg, file);
 
595
                  tree.compare, tree.custom_arg, &file);
607
596
  free((char*) merge_buffer);
608
597
  return res;
609
598
}
618
607
  SORTPARAM sort_param;
619
608
  table->sort.found_records=elements+tree.elements_in_tree;
620
609
 
621
 
  if (my_b_tell(file) == 0)
 
610
  if (my_b_tell(&file) == 0)
622
611
  {
623
612
    /* Whole tree is in memory;  Don't use disk if you don't need to */
624
613
    if ((record_pointers=table->sort.record_pointers= (unsigned char*)
633
622
  if (flush())
634
623
    return 1;
635
624
 
636
 
  internal::IO_CACHE *outfile=table->sort.io_cache;
 
625
  IO_CACHE *outfile=table->sort.io_cache;
637
626
  BUFFPEK *file_ptr= (BUFFPEK*) file_ptrs.buffer;
638
627
  uint32_t maxbuffer= file_ptrs.elements - 1;
639
628
  unsigned char *sort_buffer;
640
 
  internal::my_off_t save_pos;
 
629
  my_off_t save_pos;
641
630
  bool error=1;
642
631
 
643
632
      /* Open cached file if it isn't open */
644
 
  outfile=table->sort.io_cache= new internal::IO_CACHE;
645
 
  memset(outfile, 0, sizeof(internal::IO_CACHE));
 
633
  outfile=table->sort.io_cache= new IO_CACHE;
 
634
  memset(outfile, 0, sizeof(IO_CACHE));
646
635
 
647
636
  if (!outfile || (! my_b_inited(outfile) && open_cached_file(outfile,drizzle_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER, MYF(MY_WME))))
648
637
    return 1;
649
 
  reinit_io_cache(outfile, internal::WRITE_CACHE, 0L, 0, 0);
 
638
  reinit_io_cache(outfile, WRITE_CACHE, 0L, 0, 0);
650
639
 
651
640
  memset(&sort_param, 0, sizeof(sort_param));
652
641
  sort_param.max_rows= elements;
667
656
  sort_param.cmp_context.key_compare_arg= tree.custom_arg;
668
657
 
669
658
  /* Merge the buffers to one file, removing duplicates */
670
 
  if (merge_many_buff(&sort_param,sort_buffer,file_ptr,&maxbuffer,file))
671
 
    goto err;
672
 
  if (flush_io_cache(file) ||
673
 
      reinit_io_cache(file,internal::READ_CACHE,0L,0,0))
674
 
    goto err;
675
 
  if (merge_buffers(&sort_param, file, outfile, sort_buffer, file_ptr,
 
659
  if (merge_many_buff(&sort_param,sort_buffer,file_ptr,&maxbuffer,&file))
 
660
    goto err;
 
661
  if (flush_io_cache(&file) ||
 
662
      reinit_io_cache(&file,READ_CACHE,0L,0,0))
 
663
    goto err;
 
664
  if (merge_buffers(&sort_param, &file, outfile, sort_buffer, file_ptr,
676
665
                    file_ptr, file_ptr+maxbuffer,0))
677
666
    goto err;
678
667
  error=0;
684
673
 
685
674
  /* Setup io_cache for reading */
686
675
  save_pos=outfile->pos_in_file;
687
 
  if (reinit_io_cache(outfile,internal::READ_CACHE,0L,0,0))
 
676
  if (reinit_io_cache(outfile,READ_CACHE,0L,0,0))
688
677
    error=1;
689
678
  outfile->end_of_file=save_pos;
690
679
  return error;
691
680
}
692
 
 
693
 
} /* namespace drizzled */