← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Jay Pipes
  • Date: 2010-03-09 20:02:29 UTC
  • mto: This revision was merged to the branch mainline in revision 1339.
  • Revision ID: jpipes@serialcoder-20100309200229-dfrliy4fads9vyf4
https://launchpad.net/bugs/535296
Fixes Bug #535296 by only incrementing ha_commit_count when its a normal transaction commit.

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