← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Brian Aker
  • Date: 2010-10-22 17:44:34 UTC
  • mto: This revision was merged to the branch mainline in revision 1873.
  • Revision ID: brian@tangent.org-20101022174434-q8fjovcpclzqer7n
TableShare is no longer in the house (i.e. we no longer directly have a copy
of it in cursor).

One more bit of the knot now gone.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/filesort.cc
28
28
 
29
29
#include <queue>
30
30
#include <algorithm>
31
 
#include <iostream>
32
31
 
33
 
#include "drizzled/drizzled.h"
34
32
#include "drizzled/sql_sort.h"
35
 
#include "drizzled/filesort.h"
36
33
#include "drizzled/error.h"
37
34
#include "drizzled/probes.h"
38
35
#include "drizzled/session.h"
44
41
#include "drizzled/internal/my_sys.h"
45
42
#include "plugin/myisam/myisam.h"
46
43
#include "drizzled/plugin/transactional_storage_engine.h"
47
 
#include "drizzled/atomics.h"
48
 
#include "drizzled/global_buffer.h"
49
 
 
50
44
 
51
45
using namespace std;
52
46
 
53
47
namespace drizzled
54
48
{
55
49
 
56
 
/* Defines used by filesort and uniques */
57
 
#define MERGEBUFF               7
58
 
#define MERGEBUFF2              15
59
 
 
60
 
class BufferCompareContext
61
 
{
62
 
public:
63
 
  qsort_cmp2 key_compare;
64
 
  void *key_compare_arg;
65
 
 
66
 
  BufferCompareContext() :
67
 
    key_compare(0),
68
 
    key_compare_arg(0)
69
 
  { }
70
 
 
71
 
};
72
 
 
73
 
class SortParam {
74
 
public:
75
 
  uint32_t rec_length;          /* Length of sorted records */
76
 
  uint32_t sort_length;                 /* Length of sorted columns */
77
 
  uint32_t ref_length;                  /* Length of record ref. */
78
 
  uint32_t addon_length;        /* Length of added packed fields */
79
 
  uint32_t res_length;          /* Length of records in final sorted file/buffer */
80
 
  uint32_t keys;                                /* Max keys / buffer */
81
 
  ha_rows max_rows,examined_rows;
82
 
  Table *sort_form;                     /* For quicker make_sortkey */
83
 
  SortField *local_sortorder;
84
 
  SortField *end;
85
 
  sort_addon_field *addon_field; /* Descriptors for companion fields */
86
 
  unsigned char *unique_buff;
87
 
  bool not_killable;
88
 
  char *tmp_buffer;
89
 
  /* The fields below are used only by Unique class */
90
 
  qsort2_cmp compare;
91
 
  BufferCompareContext cmp_context;
92
 
 
93
 
  SortParam() :
94
 
    rec_length(0),
95
 
    sort_length(0),
96
 
    ref_length(0),
97
 
    addon_length(0),
98
 
    res_length(0),
99
 
    keys(0),
100
 
    max_rows(0),
101
 
    examined_rows(0),
102
 
    sort_form(0),
103
 
    local_sortorder(0),
104
 
    end(0),
105
 
    addon_field(0),
106
 
    unique_buff(0),
107
 
    not_killable(0),
108
 
    tmp_buffer(0),
109
 
    compare(0)
110
 
  {
111
 
  }
112
 
 
113
 
  ~SortParam()
114
 
  {
115
 
    if (tmp_buffer)
116
 
      free(tmp_buffer);
117
 
  }
118
 
 
119
 
  int write_keys(unsigned char * *sort_keys,
120
 
                 uint32_t count,
121
 
                 internal::IO_CACHE *buffer_file,
122
 
                 internal::IO_CACHE *tempfile);
123
 
 
124
 
  void make_sortkey(unsigned char *to,
125
 
                    unsigned char *ref_pos);
126
 
  void register_used_fields();
127
 
  bool save_index(unsigned char **sort_keys,
128
 
                  uint32_t count,
129
 
                  filesort_info *table_sort);
130
 
 
131
 
};
132
 
 
133
50
/* functions defined in this file */
134
51
 
135
52
static char **make_char_array(char **old_pos, register uint32_t fields,
139
56
                                             uint32_t count,
140
57
                                             unsigned char *buf);
141
58
 
 
59
static ha_rows find_all_keys(Session *session,
 
60
                             SORTPARAM *param,
 
61
                             optimizer::SqlSelect *select,
 
62
                             unsigned char * *sort_keys, 
 
63
                             internal::IO_CACHE *buffer_file,
 
64
                             internal::IO_CACHE *tempfile,
 
65
                             internal::IO_CACHE *indexfile);
 
66
 
 
67
static int write_keys(SORTPARAM *param,
 
68
                      unsigned char * *sort_keys,
 
69
                      uint32_t count,
 
70
                      internal::IO_CACHE *buffer_file,
 
71
                      internal::IO_CACHE *tempfile);
 
72
 
 
73
static void make_sortkey(SORTPARAM *param,
 
74
                         unsigned char *to,
 
75
                         unsigned char *ref_pos);
 
76
static void register_used_fields(SORTPARAM *param);
 
77
static int merge_index(SORTPARAM *param,
 
78
                       unsigned char *sort_buffer,
 
79
                       buffpek *buffpek,
 
80
                       uint32_t maxbuffer,
 
81
                       internal::IO_CACHE *tempfile,
 
82
                       internal::IO_CACHE *outfile);
 
83
static bool save_index(SORTPARAM *param,
 
84
                       unsigned char **sort_keys,
 
85
                       uint32_t count,
 
86
                       filesort_info *table_sort);
142
87
static uint32_t suffix_length(uint32_t string_length);
 
88
static uint32_t sortlength(Session *session,
 
89
                           SortField *sortorder,
 
90
                           uint32_t s_length,
 
91
                           bool *multi_byte_charset);
 
92
static sort_addon_field *get_addon_fields(Session *session,
 
93
                                             Field **ptabfield,
 
94
                                             uint32_t sortlength,
 
95
                                             uint32_t *plength);
143
96
static void unpack_addon_fields(sort_addon_field *addon_field,
144
97
                                unsigned char *buff);
145
 
 
146
 
FileSort::FileSort(Session &arg) :
147
 
  _session(arg)
148
 
{ 
149
 
}
150
 
 
151
98
/**
152
99
  Sort a table.
153
100
  Creates a set of pointers that can be used to read the rows
160
107
  The result set is stored in table->io_cache or
161
108
  table->record_pointers.
162
109
 
 
110
  @param session           Current thread
163
111
  @param table          Table to sort
164
112
  @param sortorder      How to sort the table
165
113
  @param s_length       Number of elements in sortorder
183
131
    examined_rows       will be set to number of examined rows
184
132
*/
185
133
 
186
 
ha_rows FileSort::run(Table *table, SortField *sortorder, uint32_t s_length,
187
 
                      optimizer::SqlSelect *select, ha_rows max_rows,
188
 
                      bool sort_positions, ha_rows &examined_rows)
 
134
ha_rows filesort(Session *session, Table *table, SortField *sortorder, uint32_t s_length,
 
135
                 optimizer::SqlSelect *select, ha_rows max_rows,
 
136
                 bool sort_positions, ha_rows *examined_rows)
189
137
{
190
 
  int error= 1;
191
 
  uint32_t memavl= 0, min_sort_memory;
 
138
  int error;
 
139
  uint32_t memavl, min_sort_memory;
192
140
  uint32_t maxbuffer;
193
 
  size_t allocated_sort_memory= 0;
194
 
  buffpek *buffpek_inst= 0;
 
141
  buffpek *buffpek_inst;
195
142
  ha_rows records= HA_POS_ERROR;
196
143
  unsigned char **sort_keys= 0;
197
 
  internal::IO_CACHE tempfile;
198
 
  internal::IO_CACHE buffpek_pointers;
199
 
  internal::IO_CACHE *selected_records_file;
200
 
  internal::IO_CACHE *outfile;
201
 
  SortParam param;
 
144
  internal::IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile;
 
145
  SORTPARAM param;
202
146
  bool multi_byte_charset;
203
147
 
204
 
  /*
205
 
    Don't use table->sort in filesort as it is also used by
206
 
    QuickIndexMergeSelect. Work with a copy and put it back at the end
207
 
    when index_merge select has finished with it.
208
 
  */
209
 
  filesort_info table_sort(table->sort);
210
 
  table->sort.io_cache= NULL;
211
 
 
 
148
  filesort_info table_sort;
212
149
  TableList *tab= table->pos_in_table_list;
213
150
  Item_subselect *subselect= tab ? tab->containing_subselect() : 0;
214
151
 
218
155
   Release InnoDB's adaptive hash index latch (if holding) before
219
156
   running a sort.
220
157
  */
221
 
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(&getSession());
 
158
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
222
159
 
 
160
  /*
 
161
    Don't use table->sort in filesort as it is also used by
 
162
    QuickIndexMergeSelect. Work with a copy and put it back at the end
 
163
    when index_merge select has finished with it.
 
164
  */
 
165
  memcpy(&table_sort, &table->sort, sizeof(filesort_info));
 
166
  table->sort.io_cache= NULL;
223
167
 
224
168
  outfile= table_sort.io_cache;
225
 
  assert(tempfile.buffer == 0);
226
 
  assert(buffpek_pointers.buffer == 0);
227
 
 
228
 
  param.sort_length= sortlength(sortorder, s_length, &multi_byte_charset);
 
169
  my_b_clear(&tempfile);
 
170
  my_b_clear(&buffpek_pointers);
 
171
  buffpek_inst=0;
 
172
  error= 1;
 
173
  memset(&param, 0, sizeof(param));
 
174
  param.sort_length= sortlength(session, sortorder, s_length, &multi_byte_charset);
229
175
  param.ref_length= table->cursor->ref_length;
230
 
 
 
176
  param.addon_field= 0;
 
177
  param.addon_length= 0;
231
178
  if (!(table->cursor->getEngine()->check_flag(HTON_BIT_FAST_KEY_READ)) && !sort_positions)
232
179
  {
233
180
    /*
234
181
      Get the descriptors of all fields whose values are appended
235
182
      to sorted fields and get its total length in param.spack_length.
236
183
    */
237
 
    param.addon_field= get_addon_fields(table->getFields(),
 
184
    param.addon_field= get_addon_fields(session, table->getFields(),
238
185
                                        param.sort_length,
239
186
                                        &param.addon_length);
240
187
  }
247
194
  {
248
195
    param.res_length= param.addon_length;
249
196
    if (!(table_sort.addon_buf= (unsigned char *) malloc(param.addon_length)))
250
 
    {
251
197
      goto err;
252
 
    }
253
198
  }
254
199
  else
255
200
  {
265
210
 
266
211
  if (select && select->quick)
267
212
  {
268
 
    getSession().status_var.filesort_range_count++;
 
213
    session->status_var.filesort_range_count++;
269
214
  }
270
215
  else
271
216
  {
272
 
    getSession().status_var.filesort_scan_count++;
 
217
    session->status_var.filesort_scan_count++;
273
218
  }
274
219
#ifdef CAN_TRUST_RANGE
275
220
  if (select && select->quick && select->quick->records > 0L)
291
236
    selected_records_file= 0;
292
237
  }
293
238
 
294
 
  if (multi_byte_charset && !(param.tmp_buffer= (char*) malloc(param.sort_length)))
295
 
  {
 
239
  if (multi_byte_charset &&
 
240
      !(param.tmp_buffer= (char*) malloc(param.sort_length)))
296
241
    goto err;
297
 
  }
298
242
 
299
 
  memavl= getSession().variables.sortbuff_size;
 
243
  memavl= session->variables.sortbuff_size;
300
244
  min_sort_memory= max((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
301
245
  while (memavl >= min_sort_memory)
302
246
  {
303
247
    uint32_t old_memavl;
304
248
    uint32_t keys= memavl/(param.rec_length+sizeof(char*));
305
249
    param.keys= (uint32_t) min(records+1, (ha_rows)keys);
306
 
 
307
 
    allocated_sort_memory= param.keys * param.rec_length;
308
 
    if (not global_sort_buffer.add(allocated_sort_memory))
309
 
    {
310
 
      my_error(ER_OUT_OF_GLOBAL_SORTMEMORY, MYF(ME_ERROR+ME_WAITTANG));
311
 
      goto err;
312
 
    }
313
 
 
314
250
    if ((table_sort.sort_keys=
315
251
         (unsigned char **) make_char_array((char **) table_sort.sort_keys,
316
252
                                            param.keys, param.rec_length)))
317
253
      break;
318
 
 
319
 
    global_sort_buffer.sub(allocated_sort_memory);
320
254
    old_memavl= memavl;
321
255
    if ((memavl= memavl/4*3) < min_sort_memory && old_memavl > min_sort_memory)
322
256
      memavl= min_sort_memory;
327
261
    my_error(ER_OUT_OF_SORTMEMORY,MYF(ME_ERROR+ME_WAITTANG));
328
262
    goto err;
329
263
  }
330
 
 
331
 
  if (buffpek_pointers.open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
332
 
  {
 
264
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir.c_str(),TEMP_PREFIX,
 
265
                       DISK_BUFFER_SIZE, MYF(MY_WME)))
333
266
    goto err;
334
 
  }
335
267
 
336
268
  param.keys--;                         /* TODO: check why we do this */
337
269
  param.sort_form= table;
338
270
  param.end=(param.local_sortorder=sortorder)+s_length;
339
 
  if ((records= find_all_keys(&param,select,sort_keys, &buffpek_pointers,
340
 
                              &tempfile, selected_records_file)) == HA_POS_ERROR)
341
 
  {
 
271
  if ((records=find_all_keys(session, &param,select,sort_keys, &buffpek_pointers,
 
272
                             &tempfile, selected_records_file)) ==
 
273
      HA_POS_ERROR)
342
274
    goto err;
343
 
  }
344
275
  maxbuffer= (uint32_t) (my_b_tell(&buffpek_pointers)/sizeof(*buffpek_inst));
345
276
 
346
277
  if (maxbuffer == 0)                   // The whole set is in memory
347
278
  {
348
 
    if (param.save_index(sort_keys,(uint32_t) records, &table_sort))
349
 
    {
 
279
    if (save_index(&param,sort_keys,(uint32_t) records, &table_sort))
350
280
      goto err;
351
 
    }
352
281
  }
353
282
  else
354
283
  {
359
288
      table_sort.buffpek = 0;
360
289
    }
361
290
    if (!(table_sort.buffpek=
362
 
          (unsigned char *) read_buffpek_from_file(&buffpek_pointers, maxbuffer, table_sort.buffpek)))
363
 
    {
 
291
          (unsigned char *) read_buffpek_from_file(&buffpek_pointers, maxbuffer,
 
292
                                 table_sort.buffpek)))
364
293
      goto err;
365
 
    }
366
294
    buffpek_inst= (buffpek *) table_sort.buffpek;
367
295
    table_sort.buffpek_len= maxbuffer;
368
 
    buffpek_pointers.close_cached_file();
 
296
    close_cached_file(&buffpek_pointers);
369
297
        /* Open cached file if it isn't open */
370
 
    if (! my_b_inited(outfile) && outfile->open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER, MYF(MY_WME)))
371
 
    {
372
 
      goto err;
373
 
    }
374
 
 
375
 
    if (outfile->reinit_io_cache(internal::WRITE_CACHE,0L,0,0))
376
 
    {
377
 
      goto err;
378
 
    }
 
298
    if (! my_b_inited(outfile) &&
 
299
        open_cached_file(outfile,drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER,
 
300
                          MYF(MY_WME)))
 
301
      goto err;
 
302
    if (reinit_io_cache(outfile,internal::WRITE_CACHE,0L,0,0))
 
303
      goto err;
379
304
 
380
305
    /*
381
306
      Use also the space previously used by string pointers in sort_buffer
382
307
      for temporary key storage.
383
308
    */
384
 
    param.keys=((param.keys*(param.rec_length+sizeof(char*))) / param.rec_length-1);
385
 
 
 
309
    param.keys=((param.keys*(param.rec_length+sizeof(char*))) /
 
310
                param.rec_length-1);
386
311
    maxbuffer--;                                // Offset from 0
387
312
    if (merge_many_buff(&param,(unsigned char*) sort_keys,buffpek_inst,&maxbuffer, &tempfile))
388
 
    {
389
 
      goto err;
390
 
    }
391
 
 
392
 
    if (flush_io_cache(&tempfile) || tempfile.reinit_io_cache(internal::READ_CACHE,0L,0,0))
393
 
    {
394
 
      goto err;
395
 
    }
396
 
 
 
313
      goto err;
 
314
    if (flush_io_cache(&tempfile) ||
 
315
        reinit_io_cache(&tempfile,internal::READ_CACHE,0L,0,0))
 
316
      goto err;
397
317
    if (merge_index(&param,(unsigned char*) sort_keys,buffpek_inst,maxbuffer,&tempfile, outfile))
398
 
    {
399
318
      goto err;
400
 
    }
401
319
  }
402
 
 
403
320
  if (records > param.max_rows)
404
 
  {
405
 
    records= param.max_rows;
406
 
  }
 
321
    records=param.max_rows;
407
322
  error =0;
408
323
 
409
324
 err:
410
 
  if (not subselect || not subselect->is_uncacheable())
 
325
  if (param.tmp_buffer)
 
326
    if (param.tmp_buffer)
 
327
      free(param.tmp_buffer);
 
328
  if (!subselect || !subselect->is_uncacheable())
411
329
  {
412
330
    free(sort_keys);
413
331
    table_sort.sort_keys= 0;
415
333
    table_sort.buffpek= 0;
416
334
    table_sort.buffpek_len= 0;
417
335
  }
418
 
 
419
 
  tempfile.close_cached_file();
420
 
  buffpek_pointers.close_cached_file();
421
 
 
 
336
  close_cached_file(&tempfile);
 
337
  close_cached_file(&buffpek_pointers);
422
338
  if (my_b_inited(outfile))
423
339
  {
424
340
    if (flush_io_cache(outfile))
425
 
    {
426
341
      error=1;
427
 
    }
428
342
    {
429
 
      internal::my_off_t save_pos= outfile->pos_in_file;
 
343
      internal::my_off_t save_pos=outfile->pos_in_file;
430
344
      /* For following reads */
431
 
      if (outfile->reinit_io_cache(internal::READ_CACHE,0L,0,0))
432
 
      {
 
345
      if (reinit_io_cache(outfile,internal::READ_CACHE,0L,0,0))
433
346
        error=1;
434
 
      }
435
347
      outfile->end_of_file=save_pos;
436
348
    }
437
349
  }
438
 
 
439
350
  if (error)
440
351
  {
441
352
    my_message(ER_FILSORT_ABORT, ER(ER_FILSORT_ABORT),
443
354
  }
444
355
  else
445
356
  {
446
 
    getSession().status_var.filesort_rows+= (uint32_t) records;
 
357
    session->status_var.filesort_rows+= (uint32_t) records;
447
358
  }
448
 
  examined_rows= param.examined_rows;
449
 
  global_sort_buffer.sub(allocated_sort_memory);
450
 
  table->sort= table_sort;
 
359
  *examined_rows= param.examined_rows;
 
360
  memcpy(&table->sort, &table_sort, sizeof(filesort_info));
451
361
  DRIZZLE_FILESORT_DONE(error, records);
452
362
  return (error ? HA_POS_ERROR : records);
453
363
} /* filesort */
454
364
 
 
365
 
 
366
void Table::filesort_free_buffers(bool full)
 
367
{
 
368
  if (sort.record_pointers)
 
369
  {
 
370
    free((unsigned char*) sort.record_pointers);
 
371
    sort.record_pointers=0;
 
372
  }
 
373
  if (full)
 
374
  {
 
375
    if (sort.sort_keys )
 
376
    {
 
377
      if ((unsigned char*) sort.sort_keys)
 
378
        free((unsigned char*) sort.sort_keys);
 
379
      sort.sort_keys= 0;
 
380
    }
 
381
    if (sort.buffpek)
 
382
    {
 
383
      if ((unsigned char*) sort.buffpek)
 
384
        free((unsigned char*) sort.buffpek);
 
385
      sort.buffpek= 0;
 
386
      sort.buffpek_len= 0;
 
387
    }
 
388
  }
 
389
  if (sort.addon_buf)
 
390
  {
 
391
    free((char *) sort.addon_buf);
 
392
    free((char *) sort.addon_field);
 
393
    sort.addon_buf=0;
 
394
    sort.addon_field=0;
 
395
  }
 
396
}
 
397
 
455
398
/** Make a array of string pointers. */
456
399
 
457
400
static char **make_char_array(char **old_pos, register uint32_t fields,
484
427
    tmp= (unsigned char *)malloc(length);
485
428
  if (tmp)
486
429
  {
487
 
    if (buffpek_pointers->reinit_io_cache(internal::READ_CACHE,0L,0,0) ||
 
430
    if (reinit_io_cache(buffpek_pointers,internal::READ_CACHE,0L,0,0) ||
488
431
        my_b_read(buffpek_pointers, (unsigned char*) tmp, length))
489
432
    {
490
433
      free((char*) tmp);
532
475
    HA_POS_ERROR on error.
533
476
*/
534
477
 
535
 
ha_rows FileSort::find_all_keys(SortParam *param, 
536
 
                                optimizer::SqlSelect *select,
537
 
                                unsigned char **sort_keys,
538
 
                                internal::IO_CACHE *buffpek_pointers,
539
 
                                internal::IO_CACHE *tempfile, internal::IO_CACHE *indexfile)
 
478
static ha_rows find_all_keys(Session *session,
 
479
                             SORTPARAM *param, 
 
480
                             optimizer::SqlSelect *select,
 
481
                             unsigned char **sort_keys,
 
482
                             internal::IO_CACHE *buffpek_pointers,
 
483
                             internal::IO_CACHE *tempfile, internal::IO_CACHE *indexfile)
540
484
{
541
485
  int error,flag,quick_select;
542
486
  uint32_t idx,indexpos,ref_length;
543
487
  unsigned char *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];
544
488
  internal::my_off_t record;
545
489
  Table *sort_form;
546
 
  volatile Session::killed_state_t *killed= getSession().getKilledPtr();
 
490
  volatile Session::killed_state *killed= &session->killed;
547
491
  Cursor *file;
548
492
  boost::dynamic_bitset<> *save_read_set= NULL;
549
493
  boost::dynamic_bitset<> *save_write_set= NULL;
565
509
  {
566
510
    next_pos=(unsigned char*) 0;                        /* Find records in sequence */
567
511
    file->startTableScan(1);
568
 
    file->extra_opt(HA_EXTRA_CACHE, getSession().variables.read_buff_size);
 
512
    file->extra_opt(HA_EXTRA_CACHE,
 
513
                    session->variables.read_buff_size);
569
514
  }
570
515
 
571
516
  ReadRecord read_record_info;
574
519
    if (select->quick->reset())
575
520
      return(HA_POS_ERROR);
576
521
 
577
 
    read_record_info.init_read_record(&getSession(), select->quick->head, select, 1, 1);
 
522
    read_record_info.init_read_record(session, select->quick->head, select, 1, 1);
578
523
  }
579
524
 
580
525
  /* Remember original bitmaps */
584
529
  sort_form->tmp_set.reset();
585
530
  /* Temporary set for register_used_fields and register_field_in_read_map */
586
531
  sort_form->read_set= &sort_form->tmp_set;
587
 
  param->register_used_fields();
 
532
  register_used_fields(param);
588
533
  if (select && select->cond)
589
534
    select->cond->walk(&Item::register_field_in_read_map, 1,
590
535
                       (unsigned char*) sort_form);
643
588
    {
644
589
      if (idx == param->keys)
645
590
      {
646
 
        if (param->write_keys(sort_keys, idx, buffpek_pointers, tempfile))
 
591
        if (write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
647
592
          return(HA_POS_ERROR);
648
593
        idx=0;
649
594
        indexpos++;
650
595
      }
651
 
      param->make_sortkey(sort_keys[idx++], ref_pos);
 
596
      make_sortkey(param,sort_keys[idx++],ref_pos);
652
597
    }
653
598
    else
654
 
    {
655
599
      file->unlock_row();
656
 
    }
657
 
 
658
600
    /* It does not make sense to read more keys in case of a fatal error */
659
 
    if (getSession().is_error())
 
601
    if (session->is_error())
660
602
      break;
661
603
  }
662
604
  if (quick_select)
674
616
      file->endTableScan();
675
617
  }
676
618
 
677
 
  if (getSession().is_error())
 
619
  if (session->is_error())
678
620
    return(HA_POS_ERROR);
679
621
 
680
622
  /* Signal we should use orignal column read and write maps */
685
627
    sort_form->print_error(error,MYF(ME_ERROR | ME_WAITTANG));
686
628
    return(HA_POS_ERROR);
687
629
  }
688
 
 
689
 
  if (indexpos && idx && param->write_keys(sort_keys,idx,buffpek_pointers,tempfile))
690
 
  {
 
630
  if (indexpos && idx &&
 
631
      write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
691
632
    return(HA_POS_ERROR);
692
 
  }
693
 
 
694
633
  return(my_b_inited(tempfile) ?
695
634
              (ha_rows) (my_b_tell(tempfile)/param->rec_length) :
696
635
              idx);
719
658
    1 Error
720
659
*/
721
660
 
722
 
int SortParam::write_keys(register unsigned char **sort_keys, uint32_t count,
723
 
                          internal::IO_CACHE *buffpek_pointers, internal::IO_CACHE *tempfile)
 
661
static int
 
662
write_keys(SORTPARAM *param, register unsigned char **sort_keys, uint32_t count,
 
663
           internal::IO_CACHE *buffpek_pointers, internal::IO_CACHE *tempfile)
724
664
{
 
665
  size_t sort_length, rec_length;
 
666
  unsigned char **end;
725
667
  buffpek buffpek;
726
668
 
 
669
  sort_length= param->sort_length;
 
670
  rec_length= param->rec_length;
727
671
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
728
672
  if (!my_b_inited(tempfile) &&
729
 
      tempfile->open_cached_file(drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE, MYF(MY_WME)))
730
 
  {
731
 
    return 1;
732
 
  }
 
673
      open_cached_file(tempfile, drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE,
 
674
                       MYF(MY_WME)))
 
675
    goto err;
733
676
  /* check we won't have more buffpeks than we can possibly keep in memory */
734
677
  if (my_b_tell(buffpek_pointers) + sizeof(buffpek) > (uint64_t)UINT_MAX)
735
 
  {
736
 
    return 1;
737
 
  }
738
 
 
 
678
    goto err;
739
679
  buffpek.file_pos= my_b_tell(tempfile);
740
 
  if ((ha_rows) count > max_rows)
741
 
    count=(uint32_t) max_rows;
742
 
 
 
680
  if ((ha_rows) count > param->max_rows)
 
681
    count=(uint32_t) param->max_rows;
743
682
  buffpek.count=(ha_rows) count;
744
 
 
745
 
  for (unsigned char **ptr= sort_keys + count ; sort_keys != ptr ; sort_keys++)
746
 
  {
 
683
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
747
684
    if (my_b_write(tempfile, (unsigned char*) *sort_keys, (uint32_t) rec_length))
748
 
    {
749
 
      return 1;
750
 
    }
751
 
  }
752
 
 
 
685
      goto err;
753
686
  if (my_b_write(buffpek_pointers, (unsigned char*) &buffpek, sizeof(buffpek)))
754
 
  {
755
 
    return 1;
756
 
  }
 
687
    goto err;
 
688
  return(0);
757
689
 
758
 
  return 0;
 
690
err:
 
691
  return(1);
759
692
} /* write_keys */
760
693
 
761
694
 
784
717
 
785
718
/** Make a sort-key from record. */
786
719
 
787
 
void SortParam::make_sortkey(register unsigned char *to, unsigned char *ref_pos)
 
720
static void make_sortkey(register SORTPARAM *param,
 
721
                         register unsigned char *to, unsigned char *ref_pos)
788
722
{
789
723
  Field *field;
790
724
  SortField *sort_field;
791
725
  size_t length;
792
726
 
793
 
  for (sort_field= local_sortorder ;
794
 
       sort_field != end ;
 
727
  for (sort_field=param->local_sortorder ;
 
728
       sort_field != param->end ;
795
729
       sort_field++)
796
730
  {
797
731
    bool maybe_null=0;
817
751
    {                                           // Item
818
752
      Item *item=sort_field->item;
819
753
      maybe_null= item->maybe_null;
820
 
 
821
754
      switch (sort_field->result_type) {
822
755
      case STRING_RESULT:
823
 
        {
824
 
          const CHARSET_INFO * const cs=item->collation.collation;
825
 
          char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');
826
 
          int diff;
827
 
          uint32_t sort_field_length;
 
756
      {
 
757
        const CHARSET_INFO * const cs=item->collation.collation;
 
758
        char fill_char= ((cs->state & MY_CS_BINSORT) ? (char) 0 : ' ');
 
759
        int diff;
 
760
        uint32_t sort_field_length;
828
761
 
 
762
        if (maybe_null)
 
763
          *to++=1;
 
764
        /* All item->str() to use some extra byte for end null.. */
 
765
        String tmp((char*) to,sort_field->length+4,cs);
 
766
        String *res= item->str_result(&tmp);
 
767
        if (!res)
 
768
        {
829
769
          if (maybe_null)
830
 
            *to++=1;
831
 
          /* All item->str() to use some extra byte for end null.. */
832
 
          String tmp((char*) to,sort_field->length+4,cs);
833
 
          String *res= item->str_result(&tmp);
834
 
          if (!res)
835
 
          {
836
 
            if (maybe_null)
837
 
              memset(to-1, 0, sort_field->length+1);
838
 
            else
839
 
            {
840
 
              /*
841
 
                This should only happen during extreme conditions if we run out
842
 
                of memory or have an item marked not null when it can be null.
843
 
                This code is here mainly to avoid a hard crash in this case.
844
 
              */
845
 
              assert(0);
846
 
              memset(to, 0, sort_field->length);        // Avoid crash
847
 
            }
848
 
            break;
849
 
          }
850
 
          length= res->length();
851
 
          sort_field_length= sort_field->length - sort_field->suffix_length;
852
 
          diff=(int) (sort_field_length - length);
853
 
          if (diff < 0)
854
 
          {
855
 
            diff=0;
856
 
            length= sort_field_length;
857
 
          }
858
 
          if (sort_field->suffix_length)
859
 
          {
860
 
            /* Store length last in result_string */
861
 
            store_length(to + sort_field_length, length,
862
 
                         sort_field->suffix_length);
863
 
          }
864
 
          if (sort_field->need_strxnfrm)
865
 
          {
866
 
            char *from=(char*) res->ptr();
867
 
            uint32_t tmp_length;
868
 
            if ((unsigned char*) from == to)
869
 
            {
870
 
              set_if_smaller(length,sort_field->length);
871
 
              memcpy(tmp_buffer,from,length);
872
 
              from= tmp_buffer;
873
 
            }
874
 
            tmp_length= my_strnxfrm(cs,to,sort_field->length,
875
 
                                    (unsigned char*) from, length);
876
 
            assert(tmp_length == sort_field->length);
877
 
          }
 
770
            memset(to-1, 0, sort_field->length+1);
878
771
          else
879
772
          {
880
 
            my_strnxfrm(cs,(unsigned char*)to,length,(const unsigned char*)res->ptr(),length);
881
 
            cs->cset->fill(cs, (char *)to+length,diff,fill_char);
 
773
            /*
 
774
              This should only happen during extreme conditions if we run out
 
775
              of memory or have an item marked not null when it can be null.
 
776
              This code is here mainly to avoid a hard crash in this case.
 
777
            */
 
778
            assert(0);
 
779
            memset(to, 0, sort_field->length);  // Avoid crash
882
780
          }
883
781
          break;
884
782
        }
 
783
        length= res->length();
 
784
        sort_field_length= sort_field->length - sort_field->suffix_length;
 
785
        diff=(int) (sort_field_length - length);
 
786
        if (diff < 0)
 
787
        {
 
788
          diff=0;
 
789
          length= sort_field_length;
 
790
        }
 
791
        if (sort_field->suffix_length)
 
792
        {
 
793
          /* Store length last in result_string */
 
794
          store_length(to + sort_field_length, length,
 
795
                       sort_field->suffix_length);
 
796
        }
 
797
        if (sort_field->need_strxnfrm)
 
798
        {
 
799
          char *from=(char*) res->ptr();
 
800
          uint32_t tmp_length;
 
801
          if ((unsigned char*) from == to)
 
802
          {
 
803
            set_if_smaller(length,sort_field->length);
 
804
            memcpy(param->tmp_buffer,from,length);
 
805
            from=param->tmp_buffer;
 
806
          }
 
807
          tmp_length= my_strnxfrm(cs,to,sort_field->length,
 
808
                                  (unsigned char*) from, length);
 
809
          assert(tmp_length == sort_field->length);
 
810
        }
 
811
        else
 
812
        {
 
813
          my_strnxfrm(cs,(unsigned char*)to,length,(const unsigned char*)res->ptr(),length);
 
814
          cs->cset->fill(cs, (char *)to+length,diff,fill_char);
 
815
        }
 
816
        break;
 
817
      }
885
818
      case INT_RESULT:
886
 
        {
 
819
        {
887
820
          int64_t value= item->val_int_result();
888
821
          if (maybe_null)
889
822
          {
890
 
            *to++=1;
 
823
            *to++=1;
891
824
            if (item->null_value)
892
825
            {
893
826
              if (maybe_null)
899
832
              break;
900
833
            }
901
834
          }
902
 
          to[7]= (unsigned char) value;
903
 
          to[6]= (unsigned char) (value >> 8);
904
 
          to[5]= (unsigned char) (value >> 16);
905
 
          to[4]= (unsigned char) (value >> 24);
906
 
          to[3]= (unsigned char) (value >> 32);
907
 
          to[2]= (unsigned char) (value >> 40);
908
 
          to[1]= (unsigned char) (value >> 48);
 
835
          to[7]= (unsigned char) value;
 
836
          to[6]= (unsigned char) (value >> 8);
 
837
          to[5]= (unsigned char) (value >> 16);
 
838
          to[4]= (unsigned char) (value >> 24);
 
839
          to[3]= (unsigned char) (value >> 32);
 
840
          to[2]= (unsigned char) (value >> 40);
 
841
          to[1]= (unsigned char) (value >> 48);
909
842
          if (item->unsigned_flag)                    /* Fix sign */
910
843
            to[0]= (unsigned char) (value >> 56);
911
844
          else
912
845
            to[0]= (unsigned char) (value >> 56) ^ 128; /* Reverse signbit */
913
 
          break;
914
 
        }
 
846
          break;
 
847
        }
915
848
      case DECIMAL_RESULT:
916
849
        {
917
850
          my_decimal dec_buf, *dec_val= item->val_decimal_result(&dec_buf);
928
861
          my_decimal2binary(E_DEC_FATAL_ERROR, dec_val, to,
929
862
                            item->max_length - (item->decimals ? 1:0),
930
863
                            item->decimals);
931
 
          break;
 
864
         break;
932
865
        }
933
866
      case REAL_RESULT:
934
 
        {
 
867
        {
935
868
          double value= item->val_result();
936
 
          if (maybe_null)
 
869
          if (maybe_null)
937
870
          {
938
871
            if (item->null_value)
939
872
            {
941
874
              to++;
942
875
              break;
943
876
            }
944
 
            *to++=1;
 
877
            *to++=1;
945
878
          }
946
 
          change_double_for_sort(value,(unsigned char*) to);
947
 
          break;
948
 
        }
 
879
          change_double_for_sort(value,(unsigned char*) to);
 
880
          break;
 
881
        }
949
882
      case ROW_RESULT:
950
883
      default:
951
 
        // This case should never be choosen
952
 
        assert(0);
953
 
        break;
 
884
        // This case should never be choosen
 
885
        assert(0);
 
886
        break;
954
887
      }
955
888
    }
956
 
 
957
889
    if (sort_field->reverse)
958
890
    {                                                   /* Revers key */
959
891
      if (maybe_null)
966
898
      }
967
899
    }
968
900
    else
969
 
    {
970
901
      to+= sort_field->length;
971
 
    }
972
902
  }
973
903
 
974
 
  if (addon_field)
 
904
  if (param->addon_field)
975
905
  {
976
906
    /*
977
907
      Save field values appended to sorted fields.
979
909
      In this implementation we use fixed layout for field values -
980
910
      the same for all records.
981
911
    */
982
 
    sort_addon_field *addonf= addon_field;
 
912
    sort_addon_field *addonf= param->addon_field;
983
913
    unsigned char *nulls= to;
984
914
    assert(addonf != 0);
985
915
    memset(nulls, 0, addonf->offset);
1011
941
  else
1012
942
  {
1013
943
    /* Save filepos last */
1014
 
    memcpy(to, ref_pos, (size_t) ref_length);
 
944
    memcpy(to, ref_pos, (size_t) param->ref_length);
1015
945
  }
 
946
  return;
1016
947
}
1017
948
 
1018
949
 
1020
951
  Register fields used by sorting in the sorted table's read set
1021
952
*/
1022
953
 
1023
 
void SortParam::register_used_fields()
 
954
static void register_used_fields(SORTPARAM *param)
1024
955
{
1025
956
  SortField *sort_field;
1026
 
  Table *table= sort_form;
 
957
  Table *table=param->sort_form;
1027
958
 
1028
 
  for (sort_field= local_sortorder ;
1029
 
       sort_field != end ;
 
959
  for (sort_field= param->local_sortorder ;
 
960
       sort_field != param->end ;
1030
961
       sort_field++)
1031
962
  {
1032
963
    Field *field;
1033
964
    if ((field= sort_field->field))
1034
965
    {
1035
966
      if (field->getTable() == table)
1036
 
        table->setReadSet(field->position());
 
967
        table->setReadSet(field->field_index);
1037
968
    }
1038
969
    else
1039
970
    {                                           // Item
1042
973
    }
1043
974
  }
1044
975
 
1045
 
  if (addon_field)
 
976
  if (param->addon_field)
1046
977
  {
1047
 
    sort_addon_field *addonf= addon_field;
 
978
    sort_addon_field *addonf= param->addon_field;
1048
979
    Field *field;
1049
980
    for ( ; (field= addonf->field) ; addonf++)
1050
 
      table->setReadSet(field->position());
 
981
      table->setReadSet(field->field_index);
1051
982
  }
1052
983
  else
1053
984
  {
1057
988
}
1058
989
 
1059
990
 
1060
 
bool SortParam::save_index(unsigned char **sort_keys, uint32_t count, filesort_info *table_sort)
 
991
static bool save_index(SORTPARAM *param, unsigned char **sort_keys, uint32_t count,
 
992
                       filesort_info *table_sort)
1061
993
{
1062
 
  uint32_t offset;
 
994
  uint32_t offset,res_length;
1063
995
  unsigned char *to;
1064
996
 
1065
 
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
1066
 
  offset= rec_length - res_length;
1067
 
 
1068
 
  if ((ha_rows) count > max_rows)
1069
 
    count=(uint32_t) max_rows;
1070
 
 
1071
 
  if (!(to= table_sort->record_pointers= (unsigned char*) malloc(res_length*count)))
1072
 
    return true;
1073
 
 
1074
 
  for (unsigned char **end_ptr= sort_keys+count ; sort_keys != end_ptr ; sort_keys++)
 
997
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, param->sort_length);
 
998
  res_length= param->res_length;
 
999
  offset= param->rec_length-res_length;
 
1000
  if ((ha_rows) count > param->max_rows)
 
1001
    count=(uint32_t) param->max_rows;
 
1002
  if (!(to= table_sort->record_pointers=
 
1003
        (unsigned char*) malloc(res_length*count)))
 
1004
    return(1);
 
1005
  for (unsigned char **end= sort_keys+count ; sort_keys != end ; sort_keys++)
1075
1006
  {
1076
1007
    memcpy(to, *sort_keys+offset, res_length);
1077
1008
    to+= res_length;
1078
1009
  }
1079
 
 
1080
 
  return false;
 
1010
  return(0);
1081
1011
}
1082
1012
 
1083
1013
 
1084
1014
/** Merge buffers to make < MERGEBUFF2 buffers. */
1085
1015
 
1086
 
int FileSort::merge_many_buff(SortParam *param, unsigned char *sort_buffer,
1087
 
                              buffpek *buffpek_inst, uint32_t *maxbuffer, internal::IO_CACHE *t_file)
 
1016
int merge_many_buff(SORTPARAM *param, unsigned char *sort_buffer,
 
1017
                    buffpek *buffpek_inst, uint32_t *maxbuffer, internal::IO_CACHE *t_file)
1088
1018
{
 
1019
  register uint32_t i;
1089
1020
  internal::IO_CACHE t_file2,*from_file,*to_file,*temp;
1090
1021
  buffpek *lastbuff;
1091
1022
 
1092
1023
  if (*maxbuffer < MERGEBUFF2)
1093
 
    return 0;
 
1024
    return(0);
1094
1025
  if (flush_io_cache(t_file) ||
1095
 
      t_file2.open_cached_file(drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE, MYF(MY_WME)))
1096
 
  {
1097
 
    return 1;
1098
 
  }
 
1026
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE,
 
1027
                        MYF(MY_WME)))
 
1028
    return(1);
1099
1029
 
1100
1030
  from_file= t_file ; to_file= &t_file2;
1101
1031
  while (*maxbuffer >= MERGEBUFF2)
1102
1032
  {
1103
 
    register uint32_t i;
1104
 
 
1105
 
    if (from_file->reinit_io_cache(internal::READ_CACHE,0L,0,0))
1106
 
    {
1107
 
      break;
1108
 
    }
1109
 
 
1110
 
    if (to_file->reinit_io_cache(internal::WRITE_CACHE,0L,0,0))
1111
 
    {
1112
 
      break;
1113
 
    }
1114
 
 
 
1033
    if (reinit_io_cache(from_file,internal::READ_CACHE,0L,0,0))
 
1034
      goto cleanup;
 
1035
    if (reinit_io_cache(to_file,internal::WRITE_CACHE,0L,0,0))
 
1036
      goto cleanup;
1115
1037
    lastbuff=buffpek_inst;
1116
1038
    for (i=0 ; i <= *maxbuffer-MERGEBUFF*3/2 ; i+=MERGEBUFF)
1117
1039
    {
1118
1040
      if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1119
1041
                        buffpek_inst+i,buffpek_inst+i+MERGEBUFF-1,0))
1120
 
      {
1121
 
        goto cleanup;
1122
 
      }
 
1042
      goto cleanup;
1123
1043
    }
1124
 
 
1125
1044
    if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1126
1045
                      buffpek_inst+i,buffpek_inst+ *maxbuffer,0))
1127
 
    {
1128
1046
      break;
1129
 
    }
1130
 
 
1131
1047
    if (flush_io_cache(to_file))
1132
 
    {
1133
1048
      break;
1134
 
    }
1135
 
 
1136
1049
    temp=from_file; from_file=to_file; to_file=temp;
1137
 
    from_file->setup_io_cache();
1138
 
    to_file->setup_io_cache();
 
1050
    setup_io_cache(from_file);
 
1051
    setup_io_cache(to_file);
1139
1052
    *maxbuffer= (uint32_t) (lastbuff-buffpek_inst)-1;
1140
1053
  }
1141
 
 
1142
1054
cleanup:
1143
 
  to_file->close_cached_file();                 // This holds old result
 
1055
  close_cached_file(to_file);                   // This holds old result
1144
1056
  if (to_file == t_file)
1145
1057
  {
1146
1058
    *t_file=t_file2;                            // Copy result file
1147
 
    t_file->setup_io_cache();
 
1059
    setup_io_cache(t_file);
1148
1060
  }
1149
1061
 
1150
1062
  return(*maxbuffer >= MERGEBUFF2);     /* Return 1 if interrupted */
1158
1070
    (uint32_t)-1 if something goes wrong
1159
1071
*/
1160
1072
 
1161
 
uint32_t FileSort::read_to_buffer(internal::IO_CACHE *fromfile, buffpek *buffpek_inst, uint32_t rec_length)
 
1073
uint32_t read_to_buffer(internal::IO_CACHE *fromfile, buffpek *buffpek_inst,
 
1074
                        uint32_t rec_length)
1162
1075
{
1163
1076
  register uint32_t count;
1164
1077
  uint32_t length;
1181
1094
{
1182
1095
  qsort2_cmp key_compare;
1183
1096
  void *key_compare_arg;
1184
 
 
1185
1097
  public:
1186
 
  compare_functor(qsort2_cmp in_key_compare, void *in_compare_arg) :
1187
 
    key_compare(in_key_compare),
1188
 
    key_compare_arg(in_compare_arg)
1189
 
  { }
1190
 
  
 
1098
  compare_functor(qsort2_cmp in_key_compare, void *in_compare_arg)
 
1099
    : key_compare(in_key_compare), key_compare_arg(in_compare_arg) { }
1191
1100
  inline bool operator()(const buffpek *i, const buffpek *j) const
1192
1101
  {
1193
 
    int val= key_compare(key_compare_arg, &i->key, &j->key);
1194
 
 
 
1102
    int val= key_compare(key_compare_arg,
 
1103
                      &i->key, &j->key);
1195
1104
    return (val >= 0);
1196
1105
  }
1197
1106
};
1215
1124
    other  error
1216
1125
*/
1217
1126
 
1218
 
int FileSort::merge_buffers(SortParam *param, internal::IO_CACHE *from_file,
1219
 
                            internal::IO_CACHE *to_file, unsigned char *sort_buffer,
1220
 
                            buffpek *lastbuff, buffpek *Fb, buffpek *Tb,
1221
 
                            int flag)
 
1127
int merge_buffers(SORTPARAM *param, internal::IO_CACHE *from_file,
 
1128
                  internal::IO_CACHE *to_file, unsigned char *sort_buffer,
 
1129
                  buffpek *lastbuff, buffpek *Fb, buffpek *Tb,
 
1130
                  int flag)
1222
1131
{
1223
1132
  int error;
1224
1133
  uint32_t rec_length,res_length,offset;
1230
1139
  buffpek *buffpek_inst;
1231
1140
  qsort2_cmp cmp;
1232
1141
  void *first_cmp_arg;
1233
 
  volatile Session::killed_state_t *killed= getSession().getKilledPtr();
1234
 
  Session::killed_state_t not_killable;
 
1142
  volatile Session::killed_state *killed= &current_session->killed;
 
1143
  Session::killed_state not_killable;
1235
1144
 
1236
 
  getSession().status_var.filesort_merge_passes++;
 
1145
  current_session->status_var.filesort_merge_passes++;
1237
1146
  if (param->not_killable)
1238
1147
  {
1239
1148
    killed= &not_killable;
1272
1181
    strpos+= (uint32_t) (error= (int) read_to_buffer(from_file, buffpek_inst,
1273
1182
                                                                         rec_length));
1274
1183
    if (error == -1)
1275
 
      return -1;
1276
 
 
 
1184
      goto err;
1277
1185
    buffpek_inst->max_keys= buffpek_inst->mem_count;    // If less data in buffers than expected
1278
1186
    queue.push(buffpek_inst);
1279
1187
  }
1292
1200
    memcpy(param->unique_buff, buffpek_inst->key, rec_length);
1293
1201
    if (my_b_write(to_file, (unsigned char*) buffpek_inst->key, rec_length))
1294
1202
    {
1295
 
      return 1;
 
1203
      error=1; goto err;
1296
1204
    }
1297
1205
    buffpek_inst->key+= rec_length;
1298
1206
    buffpek_inst->mem_count--;
1306
1214
    queue.push(buffpek_inst);
1307
1215
  }
1308
1216
  else
1309
 
  {
1310
1217
    cmp= 0;                                        // Not unique
1311
 
  }
1312
1218
 
1313
1219
  while (queue.size() > 1)
1314
1220
  {
1315
1221
    if (*killed)
1316
1222
    {
1317
 
      return 1;
 
1223
      error= 1; goto err;
1318
1224
    }
1319
1225
    for (;;)
1320
1226
    {
1330
1236
      {
1331
1237
        if (my_b_write(to_file,(unsigned char*) buffpek_inst->key, rec_length))
1332
1238
        {
1333
 
          return 1;
 
1239
          error=1; goto err;
1334
1240
        }
1335
1241
      }
1336
1242
      else
1337
1243
      {
1338
1244
        if (my_b_write(to_file, (unsigned char*) buffpek_inst->key+offset, res_length))
1339
1245
        {
1340
 
          return 1;
 
1246
          error=1; goto err;
1341
1247
        }
1342
1248
      }
1343
1249
      if (!--max_rows)
1357
1263
          break;                        /* One buffer have been removed */
1358
1264
        }
1359
1265
        else if (error == -1)
1360
 
        {
1361
 
          return -1;
1362
 
        }
 
1266
          goto err;
1363
1267
      }
1364
1268
      /* Top element has been replaced */
1365
1269
      queue.pop();
1396
1300
      if (my_b_write(to_file,(unsigned char*) buffpek_inst->key,
1397
1301
                     (rec_length*buffpek_inst->mem_count)))
1398
1302
      {
1399
 
        return 1;
 
1303
        error= 1; goto err;
1400
1304
      }
1401
1305
    }
1402
1306
    else
1409
1313
      {
1410
1314
        if (my_b_write(to_file, (unsigned char *) strpos, res_length))
1411
1315
        {
1412
 
          return 1;
 
1316
          error=1; goto err;
1413
1317
        }
1414
1318
      }
1415
1319
    }
1416
1320
  }
1417
 
 
1418
1321
  while ((error=(int) read_to_buffer(from_file,buffpek_inst, rec_length))
1419
1322
         != -1 && error != 0);
1420
1323
 
1421
1324
end:
1422
1325
  lastbuff->count= min(org_max_rows-max_rows, param->max_rows);
1423
1326
  lastbuff->file_pos= to_start_filepos;
1424
 
 
1425
 
  return error;
 
1327
err:
 
1328
  return(error);
1426
1329
} /* merge_buffers */
1427
1330
 
1428
1331
 
1429
1332
        /* Do a merge to output-file (save only positions) */
1430
1333
 
1431
 
int FileSort::merge_index(SortParam *param, unsigned char *sort_buffer,
1432
 
                          buffpek *buffpek_inst, uint32_t maxbuffer,
1433
 
                          internal::IO_CACHE *tempfile, internal::IO_CACHE *outfile)
 
1334
static int merge_index(SORTPARAM *param, unsigned char *sort_buffer,
 
1335
                       buffpek *buffpek_inst, uint32_t maxbuffer,
 
1336
                       internal::IO_CACHE *tempfile, internal::IO_CACHE *outfile)
1434
1337
{
1435
1338
  if (merge_buffers(param,tempfile,outfile,sort_buffer,buffpek_inst,buffpek_inst,
1436
1339
                    buffpek_inst+maxbuffer,1))
1437
 
    return 1;
1438
 
 
1439
 
  return 0;
 
1340
    return(1);
 
1341
  return(0);
1440
1342
} /* merge_index */
1441
1343
 
1442
1344
 
1456
1358
/**
1457
1359
  Calculate length of sort key.
1458
1360
 
 
1361
  @param session                          Thread Cursor
1459
1362
  @param sortorder                Order of items to sort
1460
1363
  @param s_length                 Number of items to sort
1461
1364
  @param[out] multi_byte_charset Set to 1 if we are using multi-byte charset
1470
1373
    Total length of sort buffer in bytes
1471
1374
*/
1472
1375
 
1473
 
uint32_t FileSort::sortlength(SortField *sortorder, uint32_t s_length, bool *multi_byte_charset)
 
1376
static uint32_t
 
1377
sortlength(Session *session, SortField *sortorder, uint32_t s_length,
 
1378
           bool *multi_byte_charset)
1474
1379
{
1475
1380
  register uint32_t length;
1476
1381
  const CHARSET_INFO *cs;
1500
1405
      sortorder->result_type= sortorder->item->result_type();
1501
1406
      if (sortorder->item->result_as_int64_t())
1502
1407
        sortorder->result_type= INT_RESULT;
1503
 
 
1504
1408
      switch (sortorder->result_type) {
1505
1409
      case STRING_RESULT:
1506
 
        sortorder->length=sortorder->item->max_length;
 
1410
        sortorder->length=sortorder->item->max_length;
1507
1411
        set_if_smaller(sortorder->length,
1508
 
                       getSession().variables.max_sort_length);
1509
 
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
1510
 
        {
 
1412
                       session->variables.max_sort_length);
 
1413
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
 
1414
        {
1511
1415
          sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
1512
 
          sortorder->need_strxnfrm= 1;
1513
 
          *multi_byte_charset= 1;
1514
 
        }
 
1416
          sortorder->need_strxnfrm= 1;
 
1417
          *multi_byte_charset= 1;
 
1418
        }
1515
1419
        else if (cs == &my_charset_bin)
1516
1420
        {
1517
1421
          /* Store length last to be able to sort blob/varbinary */
1518
1422
          sortorder->suffix_length= suffix_length(sortorder->length);
1519
1423
          sortorder->length+= sortorder->suffix_length;
1520
1424
        }
1521
 
        break;
 
1425
        break;
1522
1426
      case INT_RESULT:
1523
 
        sortorder->length=8;                    // Size of intern int64_t
1524
 
        break;
 
1427
        sortorder->length=8;                    // Size of intern int64_t
 
1428
        break;
1525
1429
      case DECIMAL_RESULT:
1526
1430
        sortorder->length=
1527
1431
          my_decimal_get_binary_size(sortorder->item->max_length -
1529
1433
                                     sortorder->item->decimals);
1530
1434
        break;
1531
1435
      case REAL_RESULT:
1532
 
        sortorder->length=sizeof(double);
1533
 
        break;
 
1436
        sortorder->length=sizeof(double);
 
1437
        break;
1534
1438
      case ROW_RESULT:
1535
 
        // This case should never be choosen
1536
 
        assert(0);
1537
 
        break;
 
1439
      default:
 
1440
        // This case should never be choosen
 
1441
        assert(0);
 
1442
        break;
1538
1443
      }
1539
1444
      if (sortorder->item->maybe_null)
1540
 
        length++;                               // Place for NULL marker
 
1445
        length++;                               // Place for NULL marker
1541
1446
    }
1542
 
    set_if_smaller(sortorder->length, (size_t)getSession().variables.max_sort_length);
 
1447
    set_if_smaller(sortorder->length,
 
1448
                   (size_t)session->variables.max_sort_length);
1543
1449
    length+=sortorder->length;
1544
1450
  }
1545
1451
  sortorder->field= (Field*) 0;                 // end marker
1559
1465
  layouts for the values of the non-sorted fields in the buffer and
1560
1466
  fills them.
1561
1467
 
 
1468
  @param session                 Current thread
1562
1469
  @param ptabfield           Array of references to the table fields
1563
1470
  @param sortlength          Total length of sorted fields
1564
1471
  @param[out] plength        Total length of appended fields
1573
1480
    NULL   if we do not store field values with sort data.
1574
1481
*/
1575
1482
 
1576
 
sort_addon_field *FileSort::get_addon_fields(Field **ptabfield, uint32_t sortlength_arg, uint32_t *plength)
 
1483
static sort_addon_field *
 
1484
get_addon_fields(Session *session, Field **ptabfield, uint32_t sortlength, uint32_t *plength)
1577
1485
{
1578
1486
  Field **pfield;
1579
1487
  Field *field;
1608
1516
    return 0;
1609
1517
  length+= (null_fields+7)/8;
1610
1518
 
1611
 
  if (length+sortlength_arg > getSession().variables.max_length_for_sort_data ||
 
1519
  if (length+sortlength > session->variables.max_length_for_sort_data ||
1612
1520
      !(addonf= (sort_addon_field *) malloc(sizeof(sort_addon_field)*
1613
1521
                                            (fields+1))))
1614
1522
    return 0;
1659
1567
*/
1660
1568
 
1661
1569
static void
1662
 
unpack_addon_fields(sort_addon_field *addon_field, unsigned char *buff)
 
1570
unpack_addon_fields(struct sort_addon_field *addon_field, unsigned char *buff)
1663
1571
{
1664
1572
  Field *field;
1665
1573
  sort_addon_field *addonf= addon_field;