← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

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