← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/uniques.cc

Merge Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/uniques.cc
39
39
#include "drizzled/sql_sort.h"
40
40
#include "drizzled/session.h"
41
41
#include "drizzled/sql_list.h"
 
42
#include "drizzled/internal/iocache.h"
42
43
 
43
44
#if defined(CMATH_NAMESPACE)
44
45
using namespace CMATH_NAMESPACE;
47
48
using namespace std;
48
49
 
49
50
 
50
 
int unique_write_to_file(unsigned char* key, element_count,
 
51
int unique_write_to_file(unsigned char* key, uint32_t,
51
52
                         Unique *unique)
52
53
{
53
54
  /*
56
57
    when tree implementation chooses to store pointer to key in TREE_ELEMENT
57
58
    (instead of storing the element itself there)
58
59
  */
59
 
  return my_b_write(&unique->file, key, unique->size) ? 1 : 0;
 
60
  return my_b_write(unique->file, key, unique->size) ? 1 : 0;
60
61
}
61
62
 
62
63
int unique_write_to_ptrs(unsigned char* key,
63
 
                         element_count, Unique *unique)
 
64
                         uint32_t, Unique *unique)
64
65
{
65
66
  memcpy(unique->record_pointers, key, unique->size);
66
67
  unique->record_pointers+=unique->size;
69
70
 
70
71
Unique::Unique(qsort_cmp2 comp_func, void * comp_func_fixed_arg,
71
72
               uint32_t size_arg, size_t max_in_memory_size_arg)
72
 
  :max_in_memory_size(max_in_memory_size_arg), size(size_arg), elements(0)
 
73
  : max_in_memory_size(max_in_memory_size_arg),
 
74
    file(static_cast<IO_CACHE *>(sql_calloc(sizeof(IO_CACHE)))),
 
75
    size(size_arg),
 
76
    elements(0)
73
77
{
74
 
  my_b_clear(&file);
 
78
  my_b_clear(file);
75
79
  init_tree(&tree, (ulong) (max_in_memory_size / 16), 0, size, comp_func, false,
76
80
            NULL, comp_func_fixed_arg);
77
81
  /* If the following fail's the next add will also fail */
81
85
  */
82
86
  max_elements= (ulong) (max_in_memory_size /
83
87
                         ALIGN_SIZE(sizeof(TREE_ELEMENT)+size));
84
 
  open_cached_file(&file, drizzle_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
 
88
  open_cached_file(file, drizzle_tmpdir,TEMP_PREFIX, DISK_BUFFER_SIZE,
85
89
                   MYF(MY_WME));
86
90
}
87
91
 
325
329
 
326
330
Unique::~Unique()
327
331
{
328
 
  close_cached_file(&file);
 
332
  close_cached_file(file);
329
333
  delete_tree(&tree);
330
334
  delete_dynamic(&file_ptrs);
331
335
}
337
341
  BUFFPEK file_ptr;
338
342
  elements+= tree.elements_in_tree;
339
343
  file_ptr.count=tree.elements_in_tree;
340
 
  file_ptr.file_pos=my_b_tell(&file);
 
344
  file_ptr.file_pos=my_b_tell(file);
341
345
 
342
346
  if (tree_walk(&tree, (tree_walk_action) unique_write_to_file,
343
347
                (void*) this, left_root_right) ||
366
370
  if (elements)
367
371
  {
368
372
    reset_dynamic(&file_ptrs);
369
 
    reinit_io_cache(&file, WRITE_CACHE, 0L, 0, 1);
 
373
    reinit_io_cache(file, WRITE_CACHE, 0L, 0, 1);
370
374
  }
371
375
  elements= 0;
372
376
}
589
593
  /* flush current tree to the file to have some memory for merge buffer */
590
594
  if (flush())
591
595
    return 1;
592
 
  if (flush_io_cache(&file) || reinit_io_cache(&file, READ_CACHE, 0L, 0, 0))
 
596
  if (flush_io_cache(file) || reinit_io_cache(file, READ_CACHE, 0L, 0, 0))
593
597
    return 1;
594
598
  if (!(merge_buffer= (unsigned char *) malloc(max_in_memory_size)))
595
599
    return 1;
597
601
                  (BUFFPEK *) file_ptrs.buffer,
598
602
                  (BUFFPEK *) file_ptrs.buffer + file_ptrs.elements,
599
603
                  action, walk_action_arg,
600
 
                  tree.compare, tree.custom_arg, &file);
 
604
                  tree.compare, tree.custom_arg, file);
601
605
  free((char*) merge_buffer);
602
606
  return res;
603
607
}
612
616
  SORTPARAM sort_param;
613
617
  table->sort.found_records=elements+tree.elements_in_tree;
614
618
 
615
 
  if (my_b_tell(&file) == 0)
 
619
  if (my_b_tell(file) == 0)
616
620
  {
617
621
    /* Whole tree is in memory;  Don't use disk if you don't need to */
618
622
    if ((record_pointers=table->sort.record_pointers= (unsigned char*)
661
665
  sort_param.cmp_context.key_compare_arg= tree.custom_arg;
662
666
 
663
667
  /* Merge the buffers to one file, removing duplicates */
664
 
  if (merge_many_buff(&sort_param,sort_buffer,file_ptr,&maxbuffer,&file))
665
 
    goto err;
666
 
  if (flush_io_cache(&file) ||
667
 
      reinit_io_cache(&file,READ_CACHE,0L,0,0))
668
 
    goto err;
669
 
  if (merge_buffers(&sort_param, &file, outfile, sort_buffer, file_ptr,
 
668
  if (merge_many_buff(&sort_param,sort_buffer,file_ptr,&maxbuffer,file))
 
669
    goto err;
 
670
  if (flush_io_cache(file) ||
 
671
      reinit_io_cache(file,READ_CACHE,0L,0,0))
 
672
    goto err;
 
673
  if (merge_buffers(&sort_param, file, outfile, sort_buffer, file_ptr,
670
674
                    file_ptr, file_ptr+maxbuffer,0))
671
675
    goto err;
672
676
  error=0;