← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/uniques.cc

  • Committer: Brian Aker
  • Date: 2008-10-06 05:57:49 UTC
  • Revision ID: brian@tangent.org-20081006055749-svg700gciuqi0zu1
Remove all of uchar.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/uniques.cc
34
34
#include "sql_sort.h"
35
35
 
36
36
 
37
 
int unique_write_to_file(uchar* key,
 
37
int unique_write_to_file(unsigned char* key,
38
38
                         element_count count __attribute__((unused)),
39
39
                         Unique *unique)
40
40
{
47
47
  return my_b_write(&unique->file, key, unique->size) ? 1 : 0;
48
48
}
49
49
 
50
 
int unique_write_to_ptrs(uchar* key,
 
50
int unique_write_to_ptrs(unsigned char* key,
51
51
                         element_count count __attribute__((unused)),
52
52
                         Unique *unique)
53
53
{
331
331
 
332
332
  if (tree_walk(&tree, (tree_walk_action) unique_write_to_file,
333
333
                (void*) this, left_root_right) ||
334
 
      insert_dynamic(&file_ptrs, (uchar*) &file_ptr))
 
334
      insert_dynamic(&file_ptrs, (unsigned char*) &file_ptr))
335
335
    return 1;
336
336
  delete_tree(&tree);
337
337
  return 0;
372
372
extern "C" {
373
373
#endif
374
374
 
375
 
static int buffpek_compare(void *arg, uchar *key_ptr1, uchar *key_ptr2)
 
375
static int buffpek_compare(void *arg, unsigned char *key_ptr1, unsigned char *key_ptr2)
376
376
{
377
377
  BUFFPEK_COMPARE_CONTEXT *ctx= (BUFFPEK_COMPARE_CONTEXT *) arg;
378
378
  return ctx->key_compare(ctx->key_compare_arg,
379
 
                          *((uchar **) key_ptr1), *((uchar **)key_ptr2));
 
379
                          *((unsigned char **) key_ptr1), *((unsigned char **)key_ptr2));
380
380
}
381
381
 
382
382
#ifdef __cplusplus
419
419
    <> 0  error
420
420
*/
421
421
 
422
 
static bool merge_walk(uchar *merge_buffer, ulong merge_buffer_size,
 
422
static bool merge_walk(unsigned char *merge_buffer, ulong merge_buffer_size,
423
423
                       uint key_length, BUFFPEK *begin, BUFFPEK *end,
424
424
                       tree_walk_action walk_action, void *walk_action_arg,
425
425
                       qsort_cmp2 compare, void *compare_arg,
434
434
    return 1;
435
435
  /* we need space for one key when a piece of merge buffer is re-read */
436
436
  merge_buffer_size-= key_length;
437
 
  uchar *save_key_buff= merge_buffer + merge_buffer_size;
 
437
  unsigned char *save_key_buff= merge_buffer + merge_buffer_size;
438
438
  uint max_key_count_per_piece= (uint) (merge_buffer_size/(end-begin) /
439
439
                                        key_length);
440
440
  /* if piece_size is aligned reuse_freed_buffer will always hit */
456
456
    if (bytes_read == (uint) (-1))
457
457
      goto end;
458
458
    assert(bytes_read);
459
 
    queue_insert(&queue, (uchar *) top);
 
459
    queue_insert(&queue, (unsigned char *) top);
460
460
  }
461
461
  top= (BUFFPEK *) queue_top(&queue);
462
462
  while (queue.elements > 1)
553
553
bool Unique::walk(tree_walk_action action, void *walk_action_arg)
554
554
{
555
555
  int res;
556
 
  uchar *merge_buffer;
 
556
  unsigned char *merge_buffer;
557
557
 
558
558
  if (elements == 0)                       /* the whole tree is in memory */
559
559
    return tree_walk(&tree, action, walk_action_arg, left_root_right);
563
563
    return 1;
564
564
  if (flush_io_cache(&file) || reinit_io_cache(&file, READ_CACHE, 0L, 0, 0))
565
565
    return 1;
566
 
  if (!(merge_buffer= (uchar *) my_malloc((ulong) max_in_memory_size, MYF(0))))
 
566
  if (!(merge_buffer= (unsigned char *) my_malloc((ulong) max_in_memory_size, MYF(0))))
567
567
    return 1;
568
568
  res= merge_walk(merge_buffer, (ulong) max_in_memory_size, size,
569
569
                  (BUFFPEK *) file_ptrs.buffer,
587
587
  if (my_b_tell(&file) == 0)
588
588
  {
589
589
    /* Whole tree is in memory;  Don't use disk if you don't need to */
590
 
    if ((record_pointers=table->sort.record_pointers= (uchar*)
 
590
    if ((record_pointers=table->sort.record_pointers= (unsigned char*)
591
591
         my_malloc(size * tree.elements_in_tree, MYF(0))))
592
592
    {
593
593
      (void) tree_walk(&tree, (tree_walk_action) unique_write_to_ptrs,
602
602
  IO_CACHE *outfile=table->sort.io_cache;
603
603
  BUFFPEK *file_ptr= (BUFFPEK*) file_ptrs.buffer;
604
604
  uint maxbuffer= file_ptrs.elements - 1;
605
 
  uchar *sort_buffer;
 
605
  unsigned char *sort_buffer;
606
606
  my_off_t save_pos;
607
607
  bool error=1;
608
608
 
622
622
  sort_param.keys= (uint) (max_in_memory_size / sort_param.sort_length);
623
623
  sort_param.not_killable=1;
624
624
 
625
 
  if (!(sort_buffer=(uchar*) my_malloc((sort_param.keys+1) *
 
625
  if (!(sort_buffer=(unsigned char*) my_malloc((sort_param.keys+1) *
626
626
                                       sort_param.sort_length,
627
627
                                       MYF(0))))
628
628
    return 1;