← 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: 2008-10-23 00:05:28 UTC
  • Revision ID: monty@inaugust.com-20081023000528-grdvrd8c4058nutm
Moved my_handler to myisam, which is where it actually belongs.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/filesort.cc
1
 
/* Copyright (C) 2000-2006 MySQL AB
 
1
/* Copyright (C) 2000-2006 MySQL AB  
2
2
 
3
3
   This program is free software; you can redistribute it and/or modify
4
4
   it under the terms of the GNU General Public License as published by
21
21
  Sorts a database
22
22
*/
23
23
 
24
 
#include "config.h"
25
 
 
26
 
#include <float.h>
27
 
#include <limits.h>
28
 
 
29
 
#include <queue>
30
 
#include <algorithm>
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"
44
 
 
45
 
using namespace std;
46
 
 
47
 
namespace drizzled
48
 
{
49
 
 
50
 
/* functions defined in this file */
 
24
#include <drizzled/server_includes.h>
 
25
#include "sql_sort.h"
 
26
#include <drizzled/drizzled_error_messages.h>
 
27
 
 
28
        /* functions defined in this file */
51
29
 
52
30
static char **make_char_array(char **old_pos, register uint32_t fields,
53
 
                              uint32_t length);
54
 
 
55
 
static unsigned char *read_buffpek_from_file(internal::IO_CACHE *buffer_file,
56
 
                                             uint32_t count,
57
 
                                             unsigned char *buf);
58
 
 
59
 
static ha_rows find_all_keys(Session *session,
60
 
                             SORTPARAM *param,
61
 
                             optimizer::SqlSelect *select,
62
 
                             unsigned char * *sort_keys, 
63
 
                             internal::IO_CACHE *buffer_file,
64
 
                             internal::IO_CACHE *tempfile,
65
 
                             internal::IO_CACHE *indexfile);
66
 
 
67
 
static int write_keys(SORTPARAM *param,
68
 
                      unsigned char * *sort_keys,
69
 
                      uint32_t count,
70
 
                      internal::IO_CACHE *buffer_file,
71
 
                      internal::IO_CACHE *tempfile);
72
 
 
73
 
static void make_sortkey(SORTPARAM *param,
74
 
                         unsigned char *to,
75
 
                         unsigned char *ref_pos);
 
31
                              uint32_t length, myf my_flag);
 
32
static unsigned char *read_buffpek_from_file(IO_CACHE *buffer_file, uint32_t count,
 
33
                                     unsigned char *buf);
 
34
static ha_rows find_all_keys(SORTPARAM *param,SQL_SELECT *select,
 
35
                             unsigned char * *sort_keys, IO_CACHE *buffer_file,
 
36
                             IO_CACHE *tempfile,IO_CACHE *indexfile);
 
37
static int write_keys(SORTPARAM *param,unsigned char * *sort_keys,
 
38
                      uint32_t count, IO_CACHE *buffer_file, IO_CACHE *tempfile);
 
39
static void make_sortkey(SORTPARAM *param,unsigned char *to, unsigned char *ref_pos);
76
40
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,
 
41
static int merge_index(SORTPARAM *param,unsigned char *sort_buffer,
 
42
                       BUFFPEK *buffpek,
 
43
                       uint32_t maxbuffer,IO_CACHE *tempfile,
 
44
                       IO_CACHE *outfile);
 
45
static bool save_index(SORTPARAM *param,unsigned char **sort_keys, uint32_t count, 
86
46
                       filesort_info_st *table_sort);
87
47
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,
 
48
static uint32_t sortlength(Session *session, SORT_FIELD *sortorder, uint32_t s_length,
 
49
                       bool *multi_byte_charset);
 
50
static SORT_ADDON_FIELD *get_addon_fields(Session *session, Field **ptabfield,
 
51
                                          uint32_t sortlength, uint32_t *plength);
 
52
static void unpack_addon_fields(struct st_sort_addon_field *addon_field,
97
53
                                unsigned char *buff);
98
54
/**
99
55
  Sort a table.
131
87
    examined_rows       will be set to number of examined rows
132
88
*/
133
89
 
134
 
ha_rows filesort(Session *session, Table *table, SortField *sortorder, uint32_t s_length,
135
 
                 optimizer::SqlSelect *select, ha_rows max_rows,
 
90
ha_rows filesort(Session *session, Table *table, SORT_FIELD *sortorder, uint32_t s_length,
 
91
                 SQL_SELECT *select, ha_rows max_rows,
136
92
                 bool sort_positions, ha_rows *examined_rows)
137
93
{
138
94
  int error;
139
95
  uint32_t memavl, min_sort_memory;
140
96
  uint32_t maxbuffer;
141
 
  buffpek_st *buffpek;
 
97
  BUFFPEK *buffpek;
142
98
  ha_rows records= HA_POS_ERROR;
143
99
  unsigned char **sort_keys= 0;
144
 
  internal::IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile;
 
100
  IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile; 
145
101
  SORTPARAM param;
146
102
  bool multi_byte_charset;
147
103
 
149
105
  TableList *tab= table->pos_in_table_list;
150
106
  Item_subselect *subselect= tab ? tab->containing_subselect() : 0;
151
107
 
152
 
  DRIZZLE_FILESORT_START(table->getShare()->getSchemaName(), table->getShare()->getTableName());
 
108
  DRIZZLE_FILESORT_START();
153
109
 
154
110
  /*
155
111
   Release InnoDB's adaptive hash index latch (if holding) before
156
112
   running a sort.
157
113
  */
158
 
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
 
114
  ha_release_temporary_latches(session);
159
115
 
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
 
116
  /* 
 
117
    Don't use table->sort in filesort as it is also used by 
 
118
    QUICK_INDEX_MERGE_SELECT. Work with a copy and put it back at the end 
163
119
    when index_merge select has finished with it.
164
120
  */
165
121
  memcpy(&table_sort, &table->sort, sizeof(filesort_info_st));
166
122
  table->sort.io_cache= NULL;
167
 
 
 
123
  
168
124
  outfile= table_sort.io_cache;
169
125
  my_b_clear(&tempfile);
170
126
  my_b_clear(&buffpek_pointers);
172
128
  error= 1;
173
129
  memset(&param, 0, sizeof(param));
174
130
  param.sort_length= sortlength(session, sortorder, s_length, &multi_byte_charset);
175
 
  param.ref_length= table->cursor->ref_length;
 
131
  param.ref_length= table->file->ref_length;
176
132
  param.addon_field= 0;
177
133
  param.addon_length= 0;
178
 
  if (!(table->cursor->getEngine()->check_flag(HTON_BIT_FAST_KEY_READ)) && !sort_positions)
 
134
  if (!(table->file->ha_table_flags() & HA_FAST_KEY_READ) && !sort_positions)
179
135
  {
180
 
    /*
181
 
      Get the descriptors of all fields whose values are appended
 
136
    /* 
 
137
      Get the descriptors of all fields whose values are appended 
182
138
      to sorted fields and get its total length in param.spack_length.
183
139
    */
184
 
    param.addon_field= get_addon_fields(session, table->getFields(),
 
140
    param.addon_field= get_addon_fields(session, table->field, 
185
141
                                        param.sort_length,
186
142
                                        &param.addon_length);
187
143
  }
193
149
  if (param.addon_field)
194
150
  {
195
151
    param.res_length= param.addon_length;
196
 
    if (!(table_sort.addon_buf= (unsigned char *) malloc(param.addon_length)))
 
152
    if (!(table_sort.addon_buf= (unsigned char *) my_malloc(param.addon_length,
 
153
                                                    MYF(MY_WME))))
197
154
      goto err;
198
155
  }
199
156
  else
200
157
  {
201
158
    param.res_length= param.ref_length;
202
 
    /*
203
 
      The reference to the record is considered
 
159
    /* 
 
160
      The reference to the record is considered 
204
161
      as an additional sorted field
205
162
    */
206
163
    param.sort_length+= param.ref_length;
210
167
 
211
168
  if (select && select->quick)
212
169
  {
213
 
    session->status_var.filesort_range_count++;
 
170
    status_var_increment(session->status_var.filesort_range_count);
214
171
  }
215
172
  else
216
173
  {
217
 
    session->status_var.filesort_scan_count++;
 
174
    status_var_increment(session->status_var.filesort_scan_count);
218
175
  }
219
176
#ifdef CAN_TRUST_RANGE
220
177
  if (select && select->quick && select->quick->records > 0L)
221
178
  {
222
 
    records= min((ha_rows) (select->quick->records*2+EXTRA_RECORDS*2),
223
 
                 table->cursor->stats.records)+EXTRA_RECORDS;
 
179
    records=cmin((ha_rows) (select->quick->records*2+EXTRA_RECORDS*2),
 
180
                table->file->stats.records)+EXTRA_RECORDS;
224
181
    selected_records_file=0;
225
182
  }
226
183
  else
227
184
#endif
228
185
  {
229
 
    records= table->cursor->estimate_rows_upper_bound();
 
186
    records= table->file->estimate_rows_upper_bound();
230
187
    /*
231
 
      If number of records is not known, use as much of sort buffer
232
 
      as possible.
 
188
      If number of records is not known, use as much of sort buffer 
 
189
      as possible. 
233
190
    */
234
191
    if (records == HA_POS_ERROR)
235
192
      records--;  // we use 'records+1' below.
237
194
  }
238
195
 
239
196
  if (multi_byte_charset &&
240
 
      !(param.tmp_buffer= (char*) malloc(param.sort_length)))
 
197
      !(param.tmp_buffer= (char*) my_malloc(param.sort_length,MYF(MY_WME))))
241
198
    goto err;
242
199
 
243
200
  memavl= session->variables.sortbuff_size;
244
 
  min_sort_memory= max((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
 
201
  min_sort_memory= cmax((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
245
202
  while (memavl >= min_sort_memory)
246
203
  {
247
204
    uint32_t old_memavl;
248
205
    uint32_t keys= memavl/(param.rec_length+sizeof(char*));
249
 
    param.keys= (uint32_t) min(records+1, (ha_rows)keys);
 
206
    param.keys=(uint32_t) cmin(records+1, keys);
250
207
    if ((table_sort.sort_keys=
251
208
         (unsigned char **) make_char_array((char **) table_sort.sort_keys,
252
 
                                            param.keys, param.rec_length)))
 
209
                                    param.keys, param.rec_length, MYF(0))))
253
210
      break;
254
 
    old_memavl= memavl;
255
 
    if ((memavl= memavl/4*3) < min_sort_memory && old_memavl > min_sort_memory)
 
211
    old_memavl=memavl;
 
212
    if ((memavl=memavl/4*3) < min_sort_memory && old_memavl > min_sort_memory)
256
213
      memavl= min_sort_memory;
257
214
  }
258
215
  sort_keys= table_sort.sort_keys;
261
218
    my_error(ER_OUT_OF_SORTMEMORY,MYF(ME_ERROR+ME_WAITTANG));
262
219
    goto err;
263
220
  }
264
 
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir.c_str(),TEMP_PREFIX,
 
221
  if (open_cached_file(&buffpek_pointers,mysql_tmpdir,TEMP_PREFIX,
265
222
                       DISK_BUFFER_SIZE, MYF(MY_WME)))
266
223
    goto err;
267
224
 
268
225
  param.keys--;                         /* TODO: check why we do this */
269
226
  param.sort_form= table;
270
227
  param.end=(param.local_sortorder=sortorder)+s_length;
271
 
  if ((records=find_all_keys(session, &param,select,sort_keys, &buffpek_pointers,
 
228
  if ((records=find_all_keys(&param,select,sort_keys, &buffpek_pointers,
272
229
                             &tempfile, selected_records_file)) ==
273
230
      HA_POS_ERROR)
274
231
    goto err;
291
248
          (unsigned char *) read_buffpek_from_file(&buffpek_pointers, maxbuffer,
292
249
                                 table_sort.buffpek)))
293
250
      goto err;
294
 
    buffpek= (buffpek_st *) table_sort.buffpek;
 
251
    buffpek= (BUFFPEK *) table_sort.buffpek;
295
252
    table_sort.buffpek_len= maxbuffer;
296
253
    close_cached_file(&buffpek_pointers);
297
254
        /* Open cached file if it isn't open */
298
255
    if (! my_b_inited(outfile) &&
299
 
        open_cached_file(outfile,drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER,
 
256
        open_cached_file(outfile,mysql_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER,
300
257
                          MYF(MY_WME)))
301
258
      goto err;
302
 
    if (reinit_io_cache(outfile,internal::WRITE_CACHE,0L,0,0))
 
259
    if (reinit_io_cache(outfile,WRITE_CACHE,0L,0,0))
303
260
      goto err;
304
261
 
305
262
    /*
313
270
                        &tempfile))
314
271
      goto err;
315
272
    if (flush_io_cache(&tempfile) ||
316
 
        reinit_io_cache(&tempfile,internal::READ_CACHE,0L,0,0))
 
273
        reinit_io_cache(&tempfile,READ_CACHE,0L,0,0))
317
274
      goto err;
318
275
    if (merge_index(&param,(unsigned char*) sort_keys,buffpek,maxbuffer,&tempfile,
319
276
                    outfile))
329
286
      free(param.tmp_buffer);
330
287
  if (!subselect || !subselect->is_uncacheable())
331
288
  {
332
 
    free(sort_keys);
 
289
    if ((unsigned char*) sort_keys)
 
290
      free((unsigned char*) sort_keys);
333
291
    table_sort.sort_keys= 0;
334
 
    free(buffpek);
 
292
    if ((unsigned char*) buffpek)
 
293
      free((unsigned char*) buffpek);
335
294
    table_sort.buffpek= 0;
336
295
    table_sort.buffpek_len= 0;
337
296
  }
342
301
    if (flush_io_cache(outfile))
343
302
      error=1;
344
303
    {
345
 
      internal::my_off_t save_pos=outfile->pos_in_file;
 
304
      my_off_t save_pos=outfile->pos_in_file;
346
305
      /* For following reads */
347
 
      if (reinit_io_cache(outfile,internal::READ_CACHE,0L,0,0))
 
306
      if (reinit_io_cache(outfile,READ_CACHE,0L,0,0))
348
307
        error=1;
349
308
      outfile->end_of_file=save_pos;
350
309
    }
351
310
  }
352
311
  if (error)
353
 
  {
354
312
    my_message(ER_FILSORT_ABORT, ER(ER_FILSORT_ABORT),
355
313
               MYF(ME_ERROR+ME_WAITTANG));
356
 
  }
357
314
  else
358
 
  {
359
 
    session->status_var.filesort_rows+= (uint32_t) records;
360
 
  }
 
315
    statistic_add(session->status_var.filesort_rows,
 
316
                  (uint32_t) records, &LOCK_status);
361
317
  *examined_rows= param.examined_rows;
362
318
  memcpy(&table->sort, &table_sort, sizeof(filesort_info_st));
363
 
  DRIZZLE_FILESORT_DONE(error, records);
364
 
  return (error ? HA_POS_ERROR : records);
 
319
  DRIZZLE_FILESORT_END();
 
320
  return(error ? HA_POS_ERROR : records);
365
321
} /* filesort */
366
322
 
367
323
 
368
 
void Table::filesort_free_buffers(bool full)
 
324
void filesort_free_buffers(Table *table, bool full)
369
325
{
370
 
  if (sort.record_pointers)
 
326
  if (table->sort.record_pointers)
371
327
  {
372
 
    free((unsigned char*) sort.record_pointers);
373
 
    sort.record_pointers=0;
 
328
    free((unsigned char*) table->sort.record_pointers);
 
329
    table->sort.record_pointers=0;
374
330
  }
375
331
  if (full)
376
332
  {
377
 
    if (sort.sort_keys )
 
333
    if (table->sort.sort_keys )
378
334
    {
379
 
      if ((unsigned char*) sort.sort_keys)
380
 
        free((unsigned char*) sort.sort_keys);
381
 
      sort.sort_keys= 0;
 
335
      if ((unsigned char*) table->sort.sort_keys)
 
336
        free((unsigned char*) table->sort.sort_keys);
 
337
      table->sort.sort_keys= 0;
382
338
    }
383
 
    if (sort.buffpek)
 
339
    if (table->sort.buffpek)
384
340
    {
385
 
      if ((unsigned char*) sort.buffpek)
386
 
        free((unsigned char*) sort.buffpek);
387
 
      sort.buffpek= 0;
388
 
      sort.buffpek_len= 0;
 
341
      if ((unsigned char*) table->sort.buffpek)
 
342
        free((unsigned char*) table->sort.buffpek);
 
343
      table->sort.buffpek= 0;
 
344
      table->sort.buffpek_len= 0;
389
345
    }
390
346
  }
391
 
  if (sort.addon_buf)
 
347
  if (table->sort.addon_buf)
392
348
  {
393
 
    free((char *) sort.addon_buf);
394
 
    free((char *) sort.addon_field);
395
 
    sort.addon_buf=0;
396
 
    sort.addon_field=0;
 
349
    free((char *) table->sort.addon_buf);
 
350
    free((char *) table->sort.addon_field);
 
351
    table->sort.addon_buf=0;
 
352
    table->sort.addon_field=0;
397
353
  }
398
354
}
399
355
 
400
356
/** Make a array of string pointers. */
401
357
 
402
358
static char **make_char_array(char **old_pos, register uint32_t fields,
403
 
                              uint32_t length)
 
359
                              uint32_t length, myf my_flag)
404
360
{
405
361
  register char **pos;
406
362
  char *char_pos;
407
363
 
408
364
  if (old_pos ||
409
 
      (old_pos= (char**) malloc((uint32_t) fields*(length+sizeof(char*)))))
 
365
      (old_pos= (char**) my_malloc((uint32_t) fields*(length+sizeof(char*)),
 
366
                                   my_flag)))
410
367
  {
411
368
    pos=old_pos; char_pos=((char*) (pos+fields)) -length;
412
369
    while (fields--) *(pos++) = (char_pos+= length);
418
375
 
419
376
/** Read 'count' number of buffer pointers into memory. */
420
377
 
421
 
static unsigned char *read_buffpek_from_file(internal::IO_CACHE *buffpek_pointers, uint32_t count,
 
378
static unsigned char *read_buffpek_from_file(IO_CACHE *buffpek_pointers, uint32_t count,
422
379
                                     unsigned char *buf)
423
380
{
424
 
  uint32_t length= sizeof(buffpek_st)*count;
 
381
  uint32_t length= sizeof(BUFFPEK)*count;
425
382
  unsigned char *tmp= buf;
426
 
  if (count > UINT_MAX/sizeof(buffpek_st))
427
 
    return 0; /* sizeof(buffpek_st)*count will overflow */
 
383
  if (count > UINT_MAX/sizeof(BUFFPEK))
 
384
    return 0; /* sizeof(BUFFPEK)*count will overflow */
428
385
  if (!tmp)
429
 
    tmp= (unsigned char *)malloc(length);
 
386
    tmp= (unsigned char *)my_malloc(length, MYF(MY_WME));
430
387
  if (tmp)
431
388
  {
432
 
    if (reinit_io_cache(buffpek_pointers,internal::READ_CACHE,0L,0,0) ||
 
389
    if (reinit_io_cache(buffpek_pointers,READ_CACHE,0L,0,0) ||
433
390
        my_b_read(buffpek_pointers, (unsigned char*) tmp, length))
434
391
    {
435
392
      free((char*) tmp);
447
404
  @param param             Sorting parameter
448
405
  @param select            Use this to get source data
449
406
  @param sort_keys         Array of pointers to sort key + addon buffers.
450
 
  @param buffpek_pointers  File to write buffpek_sts describing sorted segments
 
407
  @param buffpek_pointers  File to write BUFFPEKs describing sorted segments
451
408
                           in tempfile.
452
409
  @param tempfile          File to write sorted sequences of sortkeys to.
453
410
  @param indexfile         If !NULL, use it for source data (contains rowids)
461
418
       {
462
419
         sort sort_keys buffer;
463
420
         dump sorted sequence to 'tempfile';
464
 
         dump buffpek_st describing sequence location into 'buffpek_pointers';
 
421
         dump BUFFPEK describing sequence location into 'buffpek_pointers';
465
422
       }
466
423
       put sort key into 'sort_keys';
467
424
     }
477
434
    HA_POS_ERROR on error.
478
435
*/
479
436
 
480
 
static ha_rows find_all_keys(Session *session,
481
 
                             SORTPARAM *param, 
482
 
                             optimizer::SqlSelect *select,
 
437
static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
483
438
                             unsigned char **sort_keys,
484
 
                             internal::IO_CACHE *buffpek_pointers,
485
 
                             internal::IO_CACHE *tempfile, internal::IO_CACHE *indexfile)
 
439
                             IO_CACHE *buffpek_pointers,
 
440
                             IO_CACHE *tempfile, IO_CACHE *indexfile)
486
441
{
487
442
  int error,flag,quick_select;
488
443
  uint32_t idx,indexpos,ref_length;
489
444
  unsigned char *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];
490
 
  internal::my_off_t record;
 
445
  my_off_t record;
491
446
  Table *sort_form;
 
447
  Session *session= current_session;
492
448
  volatile Session::killed_state *killed= &session->killed;
493
 
  Cursor *file;
494
 
  MyBitmap *save_read_set, *save_write_set;
 
449
  handler *file;
 
450
  MY_BITMAP *save_read_set, *save_write_set;
495
451
 
496
452
  idx=indexpos=0;
497
453
  error=quick_select=0;
498
454
  sort_form=param->sort_form;
499
 
  file= sort_form->cursor;
 
455
  file=sort_form->file;
500
456
  ref_length=param->ref_length;
501
457
  ref_pos= ref_buff;
502
458
  quick_select=select && select->quick;
503
459
  record=0;
504
 
  flag= ((!indexfile && ! file->isOrdered())
 
460
  flag= ((!indexfile && file->ha_table_flags() & HA_REC_NOT_IN_SEQ)
505
461
         || quick_select);
506
462
  if (indexfile || flag)
507
463
    ref_pos= &file->ref[0];
509
465
  if (! indexfile && ! quick_select)
510
466
  {
511
467
    next_pos=(unsigned char*) 0;                        /* Find records in sequence */
512
 
    file->startTableScan(1);
 
468
    file->ha_rnd_init(1);
513
469
    file->extra_opt(HA_EXTRA_CACHE,
514
 
                    session->variables.read_buff_size);
 
470
                    current_session->variables.read_buff_size);
515
471
  }
516
472
 
517
 
  ReadRecord read_record_info;
 
473
  READ_RECORD read_record_info;
518
474
  if (quick_select)
519
475
  {
520
476
    if (select->quick->reset())
521
477
      return(HA_POS_ERROR);
522
 
 
523
 
    read_record_info.init_read_record(session, select->quick->head, select, 1, 1);
 
478
    init_read_record(&read_record_info, current_session, select->quick->head,
 
479
                     select, 1, 1);
524
480
  }
525
481
 
526
482
  /* Remember original bitmaps */
527
483
  save_read_set=  sort_form->read_set;
528
484
  save_write_set= sort_form->write_set;
529
485
  /* Set up temporary column read map for columns used by sort */
530
 
  sort_form->tmp_set.clearAll();
 
486
  bitmap_clear_all(&sort_form->tmp_set);
531
487
  /* Temporary set for register_used_fields and register_field_in_read_map */
532
488
  sort_form->read_set= &sort_form->tmp_set;
533
489
  register_used_fields(param);
545
501
        error= HA_ERR_END_OF_FILE;
546
502
        break;
547
503
      }
548
 
      file->position(sort_form->getInsertRecord());
 
504
      file->position(sort_form->record[0]);
549
505
    }
550
506
    else                                        /* Not quick-select */
551
507
    {
552
508
      if (indexfile)
553
509
      {
554
 
        if (my_b_read(indexfile,(unsigned char*) ref_pos,ref_length))
 
510
        if (my_b_read(indexfile,(unsigned char*) ref_pos,ref_length)) /* purecov: deadcode */
555
511
        {
556
 
          error= errno ? errno : -1;            /* Abort */
 
512
          error= my_errno ? my_errno : -1;              /* Abort */
557
513
          break;
558
514
        }
559
 
        error=file->rnd_pos(sort_form->getInsertRecord(),next_pos);
 
515
        error=file->rnd_pos(sort_form->record[0],next_pos);
560
516
      }
561
517
      else
562
518
      {
563
 
        error=file->rnd_next(sort_form->getInsertRecord());
 
519
        error=file->rnd_next(sort_form->record[0]);
 
520
        if (!error)
 
521
          update_virtual_fields_marked_for_write(sort_form);
564
522
 
565
523
        if (!flag)
566
524
        {
567
 
          internal::my_store_ptr(ref_pos,ref_length,record); // Position to row
568
 
          record+= sort_form->getShare()->db_record_offset;
 
525
          my_store_ptr(ref_pos,ref_length,record); // Position to row
 
526
          record+= sort_form->s->db_record_offset;
569
527
        }
570
528
        else if (!error)
571
 
          file->position(sort_form->getInsertRecord());
 
529
          file->position(sort_form->record[0]);
572
530
      }
573
531
      if (error && error != HA_ERR_RECORD_DELETED)
574
532
        break;
579
537
      if (!indexfile && !quick_select)
580
538
      {
581
539
        (void) file->extra(HA_EXTRA_NO_CACHE);
582
 
        file->endTableScan();
 
540
        file->ha_rnd_end();
583
541
      }
584
 
      return(HA_POS_ERROR);
 
542
      return(HA_POS_ERROR);             /* purecov: inspected */
585
543
    }
586
544
    if (error == 0)
587
545
      param->examined_rows++;
608
566
      index_merge quick select uses table->sort when retrieving rows, so free
609
567
      resoures it has allocated.
610
568
    */
611
 
    read_record_info.end_read_record();
 
569
    end_read_record(&read_record_info);
612
570
  }
613
571
  else
614
572
  {
615
573
    (void) file->extra(HA_EXTRA_NO_CACHE);      /* End cacheing of records */
616
574
    if (!next_pos)
617
 
      file->endTableScan();
 
575
      file->ha_rnd_end();
618
576
  }
619
577
 
620
578
  if (session->is_error())
621
579
    return(HA_POS_ERROR);
622
 
 
 
580
  
623
581
  /* Signal we should use orignal column read and write maps */
624
582
  sort_form->column_bitmaps_set(save_read_set, save_write_set);
625
583
 
626
584
  if (error != HA_ERR_END_OF_FILE)
627
585
  {
628
 
    sort_form->print_error(error,MYF(ME_ERROR | ME_WAITTANG));
629
 
    return(HA_POS_ERROR);
 
586
    file->print_error(error,MYF(ME_ERROR | ME_WAITTANG)); /* purecov: inspected */
 
587
    return(HA_POS_ERROR);                       /* purecov: inspected */
630
588
  }
631
589
  if (indexpos && idx &&
632
590
      write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
633
 
    return(HA_POS_ERROR);
 
591
    return(HA_POS_ERROR);                       /* purecov: inspected */
634
592
  return(my_b_inited(tempfile) ?
635
593
              (ha_rows) (my_b_tell(tempfile)/param->rec_length) :
636
594
              idx);
641
599
  @details
642
600
  Sort the buffer and write:
643
601
  -# the sorted sequence to tempfile
644
 
  -# a buffpek_st describing the sorted sequence position to buffpek_pointers
 
602
  -# a BUFFPEK describing the sorted sequence position to buffpek_pointers
645
603
 
646
604
    (was: Skriver en buffert med nycklar till filen)
647
605
 
648
606
  @param param             Sort parameters
649
607
  @param sort_keys         Array of pointers to keys to sort
650
608
  @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
 
609
  @param buffpek_pointers  One 'BUFFPEK' struct will be written into this file.
 
610
                           The BUFFPEK::{file_pos, count} will indicate where
653
611
                           the sorted data was stored.
654
612
  @param tempfile          The sorted sequence will be written into this file.
655
613
 
661
619
 
662
620
static int
663
621
write_keys(SORTPARAM *param, register unsigned char **sort_keys, uint32_t count,
664
 
           internal::IO_CACHE *buffpek_pointers, internal::IO_CACHE *tempfile)
 
622
           IO_CACHE *buffpek_pointers, IO_CACHE *tempfile)
665
623
{
666
624
  size_t sort_length, rec_length;
667
625
  unsigned char **end;
668
 
  buffpek_st buffpek;
 
626
  BUFFPEK buffpek;
669
627
 
670
628
  sort_length= param->sort_length;
671
629
  rec_length= param->rec_length;
672
 
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
 
630
  my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
673
631
  if (!my_b_inited(tempfile) &&
674
 
      open_cached_file(tempfile, drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE,
 
632
      open_cached_file(tempfile, mysql_tmpdir, TEMP_PREFIX, DISK_BUFFER_SIZE,
675
633
                       MYF(MY_WME)))
676
 
    goto err;
 
634
    goto err;                                   /* purecov: inspected */
677
635
  /* 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)
 
636
  if (my_b_tell(buffpek_pointers) + sizeof(BUFFPEK) > (uint64_t)UINT_MAX)
679
637
    goto err;
680
638
  buffpek.file_pos= my_b_tell(tempfile);
681
639
  if ((ha_rows) count > param->max_rows)
682
 
    count=(uint32_t) param->max_rows;
 
640
    count=(uint32_t) param->max_rows;               /* purecov: inspected */
683
641
  buffpek.count=(ha_rows) count;
684
642
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
685
643
    if (my_b_write(tempfile, (unsigned char*) *sort_keys, (uint32_t) rec_length))
721
679
static void make_sortkey(register SORTPARAM *param,
722
680
                         register unsigned char *to, unsigned char *ref_pos)
723
681
{
724
 
  Field *field;
725
 
  SortField *sort_field;
726
 
  size_t length;
 
682
  register Field *field;
 
683
  register SORT_FIELD *sort_field;
 
684
  register uint32_t length;
727
685
 
728
686
  for (sort_field=param->local_sortorder ;
729
687
       sort_field != param->end ;
771
729
            memset(to-1, 0, sort_field->length+1);
772
730
          else
773
731
          {
 
732
            /* purecov: begin deadcode */
774
733
            /*
775
734
              This should only happen during extreme conditions if we run out
776
735
              of memory or have an item marked not null when it can be null.
778
737
            */
779
738
            assert(0);
780
739
            memset(to, 0, sort_field->length);  // Avoid crash
 
740
            /* purecov: end */
781
741
          }
782
742
          break;
783
743
        }
821
781
          int64_t value= item->val_int_result();
822
782
          if (maybe_null)
823
783
          {
824
 
            *to++=1;
 
784
            *to++=1;                            /* purecov: inspected */
825
785
            if (item->null_value)
826
786
            {
827
787
              if (maybe_null)
852
812
          if (maybe_null)
853
813
          {
854
814
            if (item->null_value)
855
 
            {
 
815
            { 
856
816
              memset(to, 0, sort_field->length+1);
857
817
              to++;
858
818
              break;
881
841
          break;
882
842
        }
883
843
      case ROW_RESULT:
884
 
      default:
 
844
      default: 
885
845
        // This case should never be choosen
886
846
        assert(0);
887
847
        break;
904
864
 
905
865
  if (param->addon_field)
906
866
  {
907
 
    /*
 
867
    /* 
908
868
      Save field values appended to sorted fields.
909
869
      First null bit indicators are appended then field values follow.
910
870
      In this implementation we use fixed layout for field values -
911
871
      the same for all records.
912
872
    */
913
 
    sort_addon_field_st *addonf= param->addon_field;
 
873
    SORT_ADDON_FIELD *addonf= param->addon_field;
914
874
    unsigned char *nulls= to;
915
875
    assert(addonf != 0);
916
876
    memset(nulls, 0, addonf->offset);
954
914
 
955
915
static void register_used_fields(SORTPARAM *param)
956
916
{
957
 
  SortField *sort_field;
 
917
  register SORT_FIELD *sort_field;
958
918
  Table *table=param->sort_form;
 
919
  MY_BITMAP *bitmap= table->read_set;
959
920
 
960
921
  for (sort_field= param->local_sortorder ;
961
922
       sort_field != param->end ;
964
925
    Field *field;
965
926
    if ((field= sort_field->field))
966
927
    {
967
 
      if (field->getTable() == table)
968
 
        table->setReadSet(field->field_index);
 
928
      if (field->table == table)
 
929
      bitmap_set_bit(bitmap, field->field_index);
969
930
    }
970
931
    else
971
932
    {                                           // Item
976
937
 
977
938
  if (param->addon_field)
978
939
  {
979
 
    sort_addon_field_st *addonf= param->addon_field;
 
940
    SORT_ADDON_FIELD *addonf= param->addon_field;
980
941
    Field *field;
981
942
    for ( ; (field= addonf->field) ; addonf++)
982
 
      table->setReadSet(field->field_index);
 
943
      bitmap_set_bit(bitmap, field->field_index);
983
944
  }
984
945
  else
985
946
  {
989
950
}
990
951
 
991
952
 
992
 
static bool save_index(SORTPARAM *param, unsigned char **sort_keys, uint32_t count,
 
953
static bool save_index(SORTPARAM *param, unsigned char **sort_keys, uint32_t count, 
993
954
                       filesort_info_st *table_sort)
994
955
{
995
956
  uint32_t offset,res_length;
996
957
  unsigned char *to;
997
958
 
998
 
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, param->sort_length);
 
959
  my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, param->sort_length);
999
960
  res_length= param->res_length;
1000
961
  offset= param->rec_length-res_length;
1001
962
  if ((ha_rows) count > param->max_rows)
1002
963
    count=(uint32_t) param->max_rows;
1003
 
  if (!(to= table_sort->record_pointers=
1004
 
        (unsigned char*) malloc(res_length*count)))
1005
 
    return(1);
 
964
  if (!(to= table_sort->record_pointers= 
 
965
        (unsigned char*) my_malloc(res_length*count, MYF(MY_WME))))
 
966
    return(1);                 /* purecov: inspected */
1006
967
  for (unsigned char **end= sort_keys+count ; sort_keys != end ; sort_keys++)
1007
968
  {
1008
969
    memcpy(to, *sort_keys+offset, res_length);
1015
976
/** Merge buffers to make < MERGEBUFF2 buffers. */
1016
977
 
1017
978
int merge_many_buff(SORTPARAM *param, unsigned char *sort_buffer,
1018
 
                    buffpek_st *buffpek, uint32_t *maxbuffer, internal::IO_CACHE *t_file)
 
979
                    BUFFPEK *buffpek, uint32_t *maxbuffer, IO_CACHE *t_file)
1019
980
{
1020
981
  register uint32_t i;
1021
 
  internal::IO_CACHE t_file2,*from_file,*to_file,*temp;
1022
 
  buffpek_st *lastbuff;
 
982
  IO_CACHE t_file2,*from_file,*to_file,*temp;
 
983
  BUFFPEK *lastbuff;
1023
984
 
1024
985
  if (*maxbuffer < MERGEBUFF2)
1025
 
    return(0);
 
986
    return(0);                          /* purecov: inspected */
1026
987
  if (flush_io_cache(t_file) ||
1027
 
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE,
 
988
      open_cached_file(&t_file2,mysql_tmpdir,TEMP_PREFIX,DISK_BUFFER_SIZE,
1028
989
                        MYF(MY_WME)))
1029
 
    return(1);
 
990
    return(1);                          /* purecov: inspected */
1030
991
 
1031
992
  from_file= t_file ; to_file= &t_file2;
1032
993
  while (*maxbuffer >= MERGEBUFF2)
1033
994
  {
1034
 
    if (reinit_io_cache(from_file,internal::READ_CACHE,0L,0,0))
 
995
    if (reinit_io_cache(from_file,READ_CACHE,0L,0,0))
1035
996
      goto cleanup;
1036
 
    if (reinit_io_cache(to_file,internal::WRITE_CACHE,0L,0,0))
 
997
    if (reinit_io_cache(to_file,WRITE_CACHE,0L,0,0))
1037
998
      goto cleanup;
1038
999
    lastbuff=buffpek;
1039
1000
    for (i=0 ; i <= *maxbuffer-MERGEBUFF*3/2 ; i+=MERGEBUFF)
1044
1005
    }
1045
1006
    if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1046
1007
                      buffpek+i,buffpek+ *maxbuffer,0))
1047
 
      break;
 
1008
      break;                                    /* purecov: inspected */
1048
1009
    if (flush_io_cache(to_file))
1049
 
      break;
 
1010
      break;                                    /* purecov: inspected */
1050
1011
    temp=from_file; from_file=to_file; to_file=temp;
1051
1012
    setup_io_cache(from_file);
1052
1013
    setup_io_cache(to_file);
1071
1032
    (uint32_t)-1 if something goes wrong
1072
1033
*/
1073
1034
 
1074
 
uint32_t read_to_buffer(internal::IO_CACHE *fromfile, buffpek_st *buffpek,
1075
 
                        uint32_t rec_length)
 
1035
uint32_t read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
 
1036
                    uint32_t rec_length)
1076
1037
{
1077
1038
  register uint32_t count;
1078
1039
  uint32_t length;
1079
1040
 
1080
 
  if ((count= (uint32_t) min((ha_rows) buffpek->max_keys,buffpek->count)))
 
1041
  if ((count=(uint32_t) cmin((ha_rows) buffpek->max_keys,buffpek->count)))
1081
1042
  {
1082
1043
    if (pread(fromfile->file,(unsigned char*) buffpek->base, (length= rec_length*count),buffpek->file_pos) == 0)
1083
 
      return((uint32_t) -1);
1084
 
 
1085
 
    buffpek->key= buffpek->base;
 
1044
      return((uint32_t) -1);                    /* purecov: inspected */
 
1045
    buffpek->key=buffpek->base;
1086
1046
    buffpek->file_pos+= length;                 /* New filepos */
1087
 
    buffpek->count-= count;
 
1047
    buffpek->count-=    count;
1088
1048
    buffpek->mem_count= count;
1089
1049
  }
1090
1050
  return (count*rec_length);
1091
1051
} /* read_to_buffer */
1092
1052
 
1093
1053
 
1094
 
class compare_functor
 
1054
/**
 
1055
  Put all room used by freed buffer to use in adjacent buffer.
 
1056
 
 
1057
  Note, that we can't simply distribute memory evenly between all buffers,
 
1058
  because new areas must not overlap with old ones.
 
1059
 
 
1060
  @param[in] queue      list of non-empty buffers, without freed buffer
 
1061
  @param[in] reuse      empty buffer
 
1062
  @param[in] key_length key length
 
1063
*/
 
1064
 
 
1065
void reuse_freed_buff(QUEUE *queue, BUFFPEK *reuse, uint32_t key_length)
1095
1066
{
1096
 
  qsort2_cmp key_compare;
1097
 
  void *key_compare_arg;
1098
 
  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
 
1067
  unsigned char *reuse_end= reuse->base + reuse->max_keys * key_length;
 
1068
  for (uint32_t i= 0; i < queue->elements; ++i)
1102
1069
  {
1103
 
    int val= key_compare(key_compare_arg,
1104
 
                      &i->key, &j->key);
1105
 
    return (val >= 0);
 
1070
    BUFFPEK *bp= (BUFFPEK *) queue_element(queue, i);
 
1071
    if (bp->base + bp->max_keys * key_length == reuse->base)
 
1072
    {
 
1073
      bp->max_keys+= reuse->max_keys;
 
1074
      return;
 
1075
    }
 
1076
    else if (bp->base == reuse_end)
 
1077
    {
 
1078
      bp->base= reuse->base;
 
1079
      bp->max_keys+= reuse->max_keys;
 
1080
      return;
 
1081
    }
1106
1082
  }
1107
 
};
 
1083
  assert(0);
 
1084
}
1108
1085
 
1109
1086
 
1110
1087
/**
1111
1088
  Merge buffers to one buffer.
1112
1089
 
1113
1090
  @param param        Sort parameter
1114
 
  @param from_file    File with source data (buffpek_sts point to this file)
 
1091
  @param from_file    File with source data (BUFFPEKs point to this file)
1115
1092
  @param to_file      File to write the sorted result data.
1116
1093
  @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
 
1094
  @param lastbuff     OUT Store here BUFFPEK describing data written to to_file
 
1095
  @param Fb           First element in source BUFFPEKs array
 
1096
  @param Tb           Last element in source BUFFPEKs array
1120
1097
  @param flag
1121
1098
 
1122
1099
  @retval
1125
1102
    other  error
1126
1103
*/
1127
1104
 
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,
 
1105
int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
 
1106
                  IO_CACHE *to_file, unsigned char *sort_buffer,
 
1107
                  BUFFPEK *lastbuff, BUFFPEK *Fb, BUFFPEK *Tb,
1131
1108
                  int flag)
1132
1109
{
1133
1110
  int error;
1135
1112
  size_t sort_length;
1136
1113
  uint32_t maxcount;
1137
1114
  ha_rows max_rows,org_max_rows;
1138
 
  internal::my_off_t to_start_filepos;
 
1115
  my_off_t to_start_filepos;
1139
1116
  unsigned char *strpos;
1140
 
  buffpek_st *buffpek;
 
1117
  BUFFPEK *buffpek;
 
1118
  QUEUE queue;
1141
1119
  qsort2_cmp cmp;
1142
1120
  void *first_cmp_arg;
1143
1121
  volatile Session::killed_state *killed= &current_session->killed;
1144
1122
  Session::killed_state not_killable;
1145
1123
 
1146
 
  current_session->status_var.filesort_merge_passes++;
 
1124
  status_var_increment(current_session->status_var.filesort_merge_passes);
1147
1125
  if (param->not_killable)
1148
1126
  {
1149
1127
    killed= &not_killable;
1162
1140
 
1163
1141
  /* The following will fire if there is not enough space in sort_buffer */
1164
1142
  assert(maxcount!=0);
1165
 
 
 
1143
  
1166
1144
  if (param->unique_buff)
1167
1145
  {
1168
1146
    cmp= param->compare;
1170
1148
  }
1171
1149
  else
1172
1150
  {
1173
 
    cmp= internal::get_ptr_compare(sort_length);
 
1151
    cmp= get_ptr_compare(sort_length);
1174
1152
    first_cmp_arg= (void*) &sort_length;
1175
1153
  }
1176
 
  priority_queue<buffpek_st *, vector<buffpek_st *>, compare_functor > 
1177
 
    queue(compare_functor(cmp, first_cmp_arg));
 
1154
  if (init_queue(&queue, (uint32_t) (Tb-Fb)+1, offsetof(BUFFPEK,key), 0,
 
1155
                 (queue_compare) cmp, first_cmp_arg))
 
1156
    return(1);                                /* purecov: inspected */
1178
1157
  for (buffpek= Fb ; buffpek <= Tb ; buffpek++)
1179
1158
  {
1180
1159
    buffpek->base= strpos;
1182
1161
    strpos+= (uint32_t) (error= (int) read_to_buffer(from_file, buffpek,
1183
1162
                                                                         rec_length));
1184
1163
    if (error == -1)
1185
 
      goto err;
 
1164
      goto err;                                 /* purecov: inspected */
1186
1165
    buffpek->max_keys= buffpek->mem_count;      // If less data in buffers than expected
1187
 
    queue.push(buffpek);
 
1166
    queue_insert(&queue, (unsigned char*) buffpek);
1188
1167
  }
1189
1168
 
1190
1169
  if (param->unique_buff)
1191
1170
  {
1192
 
    /*
 
1171
    /* 
1193
1172
       Called by Unique::get()
1194
1173
       Copy the first argument to param->unique_buff for unique removal.
1195
1174
       Store it also in 'to_file'.
1197
1176
       This is safe as we know that there is always more than one element
1198
1177
       in each block to merge (This is guaranteed by the Unique:: algorithm
1199
1178
    */
1200
 
    buffpek= queue.top();
 
1179
    buffpek= (BUFFPEK*) queue_top(&queue);
1201
1180
    memcpy(param->unique_buff, buffpek->key, rec_length);
1202
1181
    if (my_b_write(to_file, (unsigned char*) buffpek->key, rec_length))
1203
1182
    {
1204
 
      error=1; goto err;
 
1183
      error=1; goto err;                        /* purecov: inspected */
1205
1184
    }
1206
1185
    buffpek->key+= rec_length;
1207
1186
    buffpek->mem_count--;
1208
1187
    if (!--max_rows)
1209
1188
    {
1210
 
      error= 0;
1211
 
      goto end;
 
1189
      error= 0;                                       /* purecov: inspected */
 
1190
      goto end;                                       /* purecov: inspected */
1212
1191
    }
1213
 
    /* Top element has been used */
1214
 
    queue.pop();
1215
 
    queue.push(buffpek);
 
1192
    queue_replaced(&queue);                        // Top element has been used
1216
1193
  }
1217
1194
  else
1218
1195
    cmp= 0;                                        // Not unique
1219
1196
 
1220
 
  while (queue.size() > 1)
 
1197
  while (queue.elements > 1)
1221
1198
  {
1222
1199
    if (*killed)
1223
1200
    {
1224
 
      error= 1; goto err;
 
1201
      error= 1; goto err;                        /* purecov: inspected */
1225
1202
    }
1226
1203
    for (;;)
1227
1204
    {
1228
 
      buffpek= queue.top();
 
1205
      buffpek= (BUFFPEK*) queue_top(&queue);
1229
1206
      if (cmp)                                        // Remove duplicates
1230
1207
      {
1231
1208
        if (!(*cmp)(first_cmp_arg, &(param->unique_buff),
1237
1214
      {
1238
1215
        if (my_b_write(to_file,(unsigned char*) buffpek->key, rec_length))
1239
1216
        {
1240
 
          error=1; goto err;
 
1217
          error=1; goto err;                        /* purecov: inspected */
1241
1218
        }
1242
1219
      }
1243
1220
      else
1244
1221
      {
1245
1222
        if (my_b_write(to_file, (unsigned char*) buffpek->key+offset, res_length))
1246
1223
        {
1247
 
          error=1; goto err;
 
1224
          error=1; goto err;                        /* purecov: inspected */
1248
1225
        }
1249
1226
      }
1250
1227
      if (!--max_rows)
1251
1228
      {
1252
 
        error= 0;
1253
 
        goto end;
 
1229
        error= 0;                               /* purecov: inspected */
 
1230
        goto end;                               /* purecov: inspected */
1254
1231
      }
1255
1232
 
1256
1233
    skip_duplicate:
1260
1237
        if (!(error= (int) read_to_buffer(from_file,buffpek,
1261
1238
                                          rec_length)))
1262
1239
        {
1263
 
          queue.pop();
 
1240
          queue_remove(&queue,0);
 
1241
          reuse_freed_buff(&queue, buffpek, rec_length);
1264
1242
          break;                        /* One buffer have been removed */
1265
1243
        }
1266
1244
        else if (error == -1)
1267
 
          goto err;
 
1245
          goto err;                        /* purecov: inspected */
1268
1246
      }
1269
 
      /* Top element has been replaced */
1270
 
      queue.pop();
1271
 
      queue.push(buffpek);
 
1247
      queue_replaced(&queue);              /* Top element has been replaced */
1272
1248
    }
1273
1249
  }
1274
 
  buffpek= queue.top();
 
1250
  buffpek= (BUFFPEK*) queue_top(&queue);
1275
1251
  buffpek->base= sort_buffer;
1276
1252
  buffpek->max_keys= param->keys;
1277
1253
 
1301
1277
      if (my_b_write(to_file,(unsigned char*) buffpek->key,
1302
1278
                     (rec_length*buffpek->mem_count)))
1303
1279
      {
1304
 
        error= 1; goto err;
 
1280
        error= 1; goto err;                        /* purecov: inspected */
1305
1281
      }
1306
1282
    }
1307
1283
    else
1311
1287
      for (end= strpos+buffpek->mem_count*rec_length ;
1312
1288
           strpos != end ;
1313
1289
           strpos+= rec_length)
1314
 
      {
 
1290
      {     
1315
1291
        if (my_b_write(to_file, (unsigned char *) strpos, res_length))
1316
1292
        {
1317
 
          error=1; goto err;
 
1293
          error=1; goto err;                        
1318
1294
        }
1319
1295
      }
1320
1296
    }
1323
1299
         != -1 && error != 0);
1324
1300
 
1325
1301
end:
1326
 
  lastbuff->count= min(org_max_rows-max_rows, param->max_rows);
 
1302
  lastbuff->count= cmin(org_max_rows-max_rows, param->max_rows);
1327
1303
  lastbuff->file_pos= to_start_filepos;
1328
1304
err:
 
1305
  delete_queue(&queue);
1329
1306
  return(error);
1330
1307
} /* merge_buffers */
1331
1308
 
1333
1310
        /* Do a merge to output-file (save only positions) */
1334
1311
 
1335
1312
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)
 
1313
                       BUFFPEK *buffpek, uint32_t maxbuffer,
 
1314
                       IO_CACHE *tempfile, IO_CACHE *outfile)
1338
1315
{
1339
1316
  if (merge_buffers(param,tempfile,outfile,sort_buffer,buffpek,buffpek,
1340
1317
                    buffpek+maxbuffer,1))
1341
 
    return(1);
 
1318
    return(1);                          /* purecov: inspected */
1342
1319
  return(0);
1343
1320
} /* merge_index */
1344
1321
 
1359
1336
/**
1360
1337
  Calculate length of sort key.
1361
1338
 
1362
 
  @param session                          Thread Cursor
 
1339
  @param session                          Thread handler
1363
1340
  @param sortorder                Order of items to sort
1364
1341
  @param s_length                 Number of items to sort
1365
1342
  @param[out] multi_byte_charset Set to 1 if we are using multi-byte charset
1375
1352
*/
1376
1353
 
1377
1354
static uint32_t
1378
 
sortlength(Session *session, SortField *sortorder, uint32_t s_length,
 
1355
sortlength(Session *session, SORT_FIELD *sortorder, uint32_t s_length,
1379
1356
           bool *multi_byte_charset)
1380
1357
{
1381
1358
  register uint32_t length;
1409
1386
      switch (sortorder->result_type) {
1410
1387
      case STRING_RESULT:
1411
1388
        sortorder->length=sortorder->item->max_length;
1412
 
        set_if_smaller(sortorder->length,
1413
 
                       session->variables.max_sort_length);
 
1389
        set_if_smaller(sortorder->length, session->variables.max_sort_length);
1414
1390
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
1415
 
        {
 
1391
        { 
1416
1392
          sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
1417
1393
          sortorder->need_strxnfrm= 1;
1418
1394
          *multi_byte_charset= 1;
1429
1405
        break;
1430
1406
      case DECIMAL_RESULT:
1431
1407
        sortorder->length=
1432
 
          my_decimal_get_binary_size(sortorder->item->max_length -
 
1408
          my_decimal_get_binary_size(sortorder->item->max_length - 
1433
1409
                                     (sortorder->item->decimals ? 1 : 0),
1434
1410
                                     sortorder->item->decimals);
1435
1411
        break;
1437
1413
        sortorder->length=sizeof(double);
1438
1414
        break;
1439
1415
      case ROW_RESULT:
1440
 
      default:
 
1416
      default: 
1441
1417
        // This case should never be choosen
1442
1418
        assert(0);
1443
1419
        break;
1445
1421
      if (sortorder->item->maybe_null)
1446
1422
        length++;                               // Place for NULL marker
1447
1423
    }
1448
 
    set_if_smaller(sortorder->length,
1449
 
                   (size_t)session->variables.max_sort_length);
 
1424
    set_if_smaller(sortorder->length, session->variables.max_sort_length);
1450
1425
    length+=sortorder->length;
1451
1426
  }
1452
1427
  sortorder->field= (Field*) 0;                 // end marker
1460
1435
 
1461
1436
  The function first finds out what fields are used in the result set.
1462
1437
  Then it calculates the length of the buffer to store the values of
1463
 
  these fields together with the value of sort values.
 
1438
  these fields together with the value of sort values. 
1464
1439
  If the calculated length is not greater than max_length_for_sort_data
1465
1440
  the function allocates memory for an array of descriptors containing
1466
1441
  layouts for the values of the non-sorted fields in the buffer and
1481
1456
    NULL   if we do not store field values with sort data.
1482
1457
*/
1483
1458
 
1484
 
static sort_addon_field_st *
 
1459
static SORT_ADDON_FIELD *
1485
1460
get_addon_fields(Session *session, Field **ptabfield, uint32_t sortlength, uint32_t *plength)
1486
1461
{
1487
1462
  Field **pfield;
1488
1463
  Field *field;
1489
 
  sort_addon_field_st *addonf;
 
1464
  SORT_ADDON_FIELD *addonf;
1490
1465
  uint32_t length= 0;
1491
1466
  uint32_t fields= 0;
1492
1467
  uint32_t null_fields= 0;
 
1468
  MY_BITMAP *read_set= (*ptabfield)->table->read_set;
1493
1469
 
1494
1470
  /*
1495
1471
    If there is a reference to a field in the query add it
1497
1473
    Note for future refinement:
1498
1474
    This this a too strong condition.
1499
1475
    Actually we need only the fields referred in the
1500
 
    result set. And for some of them it makes sense to use
 
1476
    result set. And for some of them it makes sense to use 
1501
1477
    the values directly from sorted fields.
1502
1478
  */
1503
1479
  *plength= 0;
1504
1480
 
1505
1481
  for (pfield= ptabfield; (field= *pfield) ; pfield++)
1506
1482
  {
1507
 
    if (!(field->isReadSet()))
 
1483
    if (!bitmap_is_set(read_set, field->field_index))
1508
1484
      continue;
1509
1485
    if (field->flags & BLOB_FLAG)
1510
1486
      return 0;
1512
1488
    if (field->maybe_null())
1513
1489
      null_fields++;
1514
1490
    fields++;
1515
 
  }
 
1491
  } 
1516
1492
  if (!fields)
1517
1493
    return 0;
1518
1494
  length+= (null_fields+7)/8;
1519
1495
 
1520
1496
  if (length+sortlength > session->variables.max_length_for_sort_data ||
1521
 
      !(addonf= (sort_addon_field_st *) malloc(sizeof(sort_addon_field_st)*
1522
 
                                            (fields+1))))
 
1497
      !(addonf= (SORT_ADDON_FIELD *) my_malloc(sizeof(SORT_ADDON_FIELD)*
 
1498
                                               (fields+1), MYF(MY_WME))))
1523
1499
    return 0;
1524
1500
 
1525
1501
  *plength= length;
1527
1503
  null_fields= 0;
1528
1504
  for (pfield= ptabfield; (field= *pfield) ; pfield++)
1529
1505
  {
1530
 
    if (!(field->isReadSet()))
 
1506
    if (!bitmap_is_set(read_set, field->field_index))
1531
1507
      continue;
1532
1508
    addonf->field= field;
1533
1509
    addonf->offset= length;
1547
1523
    addonf++;
1548
1524
  }
1549
1525
  addonf->field= 0;     // Put end marker
1550
 
 
 
1526
  
1551
1527
  return (addonf-fields);
1552
1528
}
1553
1529
 
1567
1543
    void.
1568
1544
*/
1569
1545
 
1570
 
static void
1571
 
unpack_addon_fields(struct sort_addon_field_st *addon_field, unsigned char *buff)
 
1546
static void 
 
1547
unpack_addon_fields(struct st_sort_addon_field *addon_field, unsigned char *buff)
1572
1548
{
1573
1549
  Field *field;
1574
 
  sort_addon_field_st *addonf= addon_field;
 
1550
  SORT_ADDON_FIELD *addonf= addon_field;
1575
1551
 
1576
1552
  for ( ; (field= addonf->field) ; addonf++)
1577
1553
  {
1632
1608
    }
1633
1609
  }
1634
1610
}
1635
 
 
1636
 
} /* namespace drizzled */