~drizzle-trunk/drizzle/development

 

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

/* functions defined in this file */

 

static char **make_char_array(char **old_pos, register uint32_t fields,

static unsigned char *read_buffpek_from_file(IO_CACHE *buffer_file, uint32_t count,

                                     unsigned char *buf);

static ha_rows find_all_keys(SORTPARAM *param,SQL_SELECT *select,

                       BUFFPEK *buffpek,

                       uint32_t maxbuffer,IO_CACHE *tempfile,

                       IO_CACHE *outfile);

                       filesort_info_st *table_sort);

static uint32_t suffix_length(uint32_t string_length);

static uint32_t sortlength(Session *session, SORT_FIELD *sortorder, uint32_t s_length,

  BUFFPEK *buffpek;

  ha_rows records= HA_POS_ERROR;

  unsigned char **sort_keys= 0;

  SORTPARAM param;

  bool multi_byte_charset;

 

  */

  ha_release_temporary_latches(session);

 

    when index_merge select has finished with it.

  */

  memcpy(&table_sort, &table->sort, sizeof(filesort_info_st));

  table->sort.io_cache= NULL;

  outfile= table_sort.io_cache;

  my_b_clear(&tempfile);

  my_b_clear(&buffpek_pointers);

  param.addon_length= 0;

  if (!(table->file->ha_table_flags() & HA_FAST_KEY_READ) && !sort_positions)

  {

      to sorted fields and get its total length in param.spack_length.

    */

                                        param.sort_length,

                                        &param.addon_length);

  }

  if (param.addon_field)

  {

    param.res_length= param.addon_length;

      goto err;

  }

  else

  {

    param.res_length= param.ref_length;

      as an additional sorted field

    */

    param.sort_length+= param.ref_length;

  {

    records= table->file->estimate_rows_upper_bound();

    /*

    */

    if (records == HA_POS_ERROR)

      records--;  // we use 'records+1' below.

  }

 

  if (multi_byte_charset &&

    goto err;

 

  memavl= session->variables.sortbuff_size;

    param.keys=(uint32_t) cmin(records+1, keys);

    if ((table_sort.sort_keys=

         (unsigned char **) make_char_array((char **) table_sort.sort_keys,

      break;

    old_memavl=memavl;

    if ((memavl=memavl/4*3) < min_sort_memory && old_memavl > min_sort_memory)

/** Make a array of string pointers. */

 

static char **make_char_array(char **old_pos, register uint32_t fields,

{

  register char **pos;

  char *char_pos;

 

  if (old_pos ||

  {

    pos=old_pos; char_pos=((char*) (pos+fields)) -length;

    while (fields--) *(pos++) = (char_pos+= length);

  if (count > UINT_MAX/sizeof(BUFFPEK))

    return 0; /* sizeof(BUFFPEK)*count will overflow */

  if (!tmp)

  if (tmp)

  {

    if (reinit_io_cache(buffpek_pointers,READ_CACHE,0L,0,0) ||

 

  if (session->is_error())

    return(HA_POS_ERROR);

  /* Signal we should use orignal column read and write maps */

  sort_form->column_bitmaps_set(save_read_set, save_write_set);

 

          if (maybe_null)

          {

            if (item->null_value)

              memset(to, 0, sort_field->length+1);

              to++;

              break;

          break;

        }

      case ROW_RESULT:

        // This case should never be choosen

        assert(0);

        break;

 

  if (param->addon_field)

  {

      Save field values appended to sorted fields.

      First null bit indicators are appended then field values follow.

      In this implementation we use fixed layout for field values -

}

 

 

                       filesort_info_st *table_sort)

{

  uint32_t offset,res_length;

  offset= param->rec_length-res_length;

  if ((ha_rows) count > param->max_rows)

    count=(uint32_t) param->max_rows;

    return(1);                 /* purecov: inspected */

  for (unsigned char **end= sort_keys+count ; sort_keys != end ; sort_keys++)

  {

 

  /* The following will fire if there is not enough space in sort_buffer */

  assert(maxcount!=0);

  if (param->unique_buff)

  {

    cmp= param->compare;

 

  if (param->unique_buff)

  {

       Called by Unique::get()

       Copy the first argument to param->unique_buff for unique removal.

       Store it also in 'to_file'.

      for (end= strpos+buffpek->mem_count*rec_length ;

           strpos != end ;

           strpos+= rec_length)

        if (my_b_write(to_file, (unsigned char *) strpos, res_length))

        {

        }

      }

    }

        sortorder->length=sortorder->item->max_length;

        set_if_smaller(sortorder->length, session->variables.max_sort_length);

        if (use_strnxfrm((cs=sortorder->item->collation.collation)))

          sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);

          sortorder->need_strxnfrm= 1;

          *multi_byte_charset= 1;