← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

code clean move Item_func_abs, Item_func_int_exp, Item_func_ln, Item_func_log to functions directory

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(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);
 
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);
75
40
static void register_used_fields(SORTPARAM *param);
76
 
static int merge_index(SORTPARAM *param,
77
 
                       unsigned char *sort_buffer,
 
41
static int merge_index(SORTPARAM *param,unsigned char *sort_buffer,
78
42
                       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,
 
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, 
85
46
                       filesort_info_st *table_sort);
86
47
static uint32_t suffix_length(uint32_t string_length);
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);
 
48
static uint32_t sortlength(THD *thd, SORT_FIELD *sortorder, uint32_t s_length,
 
49
                       bool *multi_byte_charset);
 
50
static SORT_ADDON_FIELD *get_addon_fields(THD *thd, Field **ptabfield,
 
51
                                          uint32_t sortlength, uint32_t *plength);
95
52
static void unpack_addon_fields(struct st_sort_addon_field *addon_field,
96
53
                                unsigned char *buff);
97
54
/**
106
63
  The result set is stored in table->io_cache or
107
64
  table->record_pointers.
108
65
 
109
 
  @param session           Current thread
 
66
  @param thd           Current thread
110
67
  @param table          Table to sort
111
68
  @param sortorder      How to sort the table
112
69
  @param s_length       Number of elements in sortorder
130
87
    examined_rows       will be set to number of examined rows
131
88
*/
132
89
 
133
 
ha_rows filesort(Session *session, Table *table, SORT_FIELD *sortorder, uint32_t s_length,
134
 
                 optimizer::SqlSelect *select, ha_rows max_rows,
 
90
ha_rows filesort(THD *thd, Table *table, SORT_FIELD *sortorder, uint32_t s_length,
 
91
                 SQL_SELECT *select, ha_rows max_rows,
135
92
                 bool sort_positions, ha_rows *examined_rows)
136
93
{
137
94
  int error;
140
97
  BUFFPEK *buffpek;
141
98
  ha_rows records= HA_POS_ERROR;
142
99
  unsigned char **sort_keys= 0;
143
 
  internal::IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile;
 
100
  IO_CACHE tempfile, buffpek_pointers, *selected_records_file, *outfile; 
144
101
  SORTPARAM param;
145
102
  bool multi_byte_charset;
146
103
 
148
105
  TableList *tab= table->pos_in_table_list;
149
106
  Item_subselect *subselect= tab ? tab->containing_subselect() : 0;
150
107
 
151
 
  DRIZZLE_FILESORT_START(table->s->getSchemaName(), table->s->getTableName());
 
108
  DRIZZLE_FILESORT_START();
152
109
 
153
110
  /*
154
111
   Release InnoDB's adaptive hash index latch (if holding) before
155
112
   running a sort.
156
113
  */
157
 
  plugin::TransactionalStorageEngine::releaseTemporaryLatches(session);
 
114
  ha_release_temporary_latches(thd);
158
115
 
159
 
  /*
160
 
    Don't use table->sort in filesort as it is also used by
161
 
    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 
162
119
    when index_merge select has finished with it.
163
120
  */
164
121
  memcpy(&table_sort, &table->sort, sizeof(filesort_info_st));
165
122
  table->sort.io_cache= NULL;
166
 
 
 
123
  
167
124
  outfile= table_sort.io_cache;
168
125
  my_b_clear(&tempfile);
169
126
  my_b_clear(&buffpek_pointers);
170
127
  buffpek=0;
171
128
  error= 1;
172
129
  memset(&param, 0, sizeof(param));
173
 
  param.sort_length= sortlength(session, sortorder, s_length, &multi_byte_charset);
174
 
  param.ref_length= table->cursor->ref_length;
 
130
  param.sort_length= sortlength(thd, sortorder, s_length, &multi_byte_charset);
 
131
  param.ref_length= table->file->ref_length;
175
132
  param.addon_field= 0;
176
133
  param.addon_length= 0;
177
 
  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)
178
135
  {
179
 
    /*
180
 
      Get the descriptors of all fields whose values are appended
 
136
    /* 
 
137
      Get the descriptors of all fields whose values are appended 
181
138
      to sorted fields and get its total length in param.spack_length.
182
139
    */
183
 
    param.addon_field= get_addon_fields(session, table->field,
 
140
    param.addon_field= get_addon_fields(thd, table->field, 
184
141
                                        param.sort_length,
185
142
                                        &param.addon_length);
186
143
  }
192
149
  if (param.addon_field)
193
150
  {
194
151
    param.res_length= param.addon_length;
195
 
    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))))
196
154
      goto err;
197
155
  }
198
156
  else
199
157
  {
200
158
    param.res_length= param.ref_length;
201
 
    /*
202
 
      The reference to the record is considered
 
159
    /* 
 
160
      The reference to the record is considered 
203
161
      as an additional sorted field
204
162
    */
205
163
    param.sort_length+= param.ref_length;
209
167
 
210
168
  if (select && select->quick)
211
169
  {
212
 
    status_var_increment(session->status_var.filesort_range_count);
 
170
    status_var_increment(thd->status_var.filesort_range_count);
213
171
  }
214
172
  else
215
173
  {
216
 
    status_var_increment(session->status_var.filesort_scan_count);
 
174
    status_var_increment(thd->status_var.filesort_scan_count);
217
175
  }
218
176
#ifdef CAN_TRUST_RANGE
219
177
  if (select && select->quick && select->quick->records > 0L)
220
178
  {
221
 
    records= min((ha_rows) (select->quick->records*2+EXTRA_RECORDS*2),
222
 
                 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;
223
181
    selected_records_file=0;
224
182
  }
225
183
  else
226
184
#endif
227
185
  {
228
 
    records= table->cursor->estimate_rows_upper_bound();
 
186
    records= table->file->estimate_rows_upper_bound();
229
187
    /*
230
 
      If number of records is not known, use as much of sort buffer
231
 
      as possible.
 
188
      If number of records is not known, use as much of sort buffer 
 
189
      as possible. 
232
190
    */
233
191
    if (records == HA_POS_ERROR)
234
192
      records--;  // we use 'records+1' below.
236
194
  }
237
195
 
238
196
  if (multi_byte_charset &&
239
 
      !(param.tmp_buffer= (char*) malloc(param.sort_length)))
 
197
      !(param.tmp_buffer= (char*) my_malloc(param.sort_length,MYF(MY_WME))))
240
198
    goto err;
241
199
 
242
 
  memavl= session->variables.sortbuff_size;
243
 
  min_sort_memory= max((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
 
200
  memavl= thd->variables.sortbuff_size;
 
201
  min_sort_memory= cmax((uint32_t)MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
244
202
  while (memavl >= min_sort_memory)
245
203
  {
246
204
    uint32_t old_memavl;
247
205
    uint32_t keys= memavl/(param.rec_length+sizeof(char*));
248
 
    param.keys= (uint32_t) min(records+1, (ha_rows)keys);
 
206
    param.keys=(uint32_t) cmin(records+1, keys);
249
207
    if ((table_sort.sort_keys=
250
208
         (unsigned char **) make_char_array((char **) table_sort.sort_keys,
251
 
                                            param.keys, param.rec_length)))
 
209
                                    param.keys, param.rec_length, MYF(0))))
252
210
      break;
253
 
    old_memavl= memavl;
254
 
    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)
255
213
      memavl= min_sort_memory;
256
214
  }
257
215
  sort_keys= table_sort.sort_keys;
260
218
    my_error(ER_OUT_OF_SORTMEMORY,MYF(ME_ERROR+ME_WAITTANG));
261
219
    goto err;
262
220
  }
263
 
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir,TEMP_PREFIX,
 
221
  if (open_cached_file(&buffpek_pointers,mysql_tmpdir,TEMP_PREFIX,
264
222
                       DISK_BUFFER_SIZE, MYF(MY_WME)))
265
223
    goto err;
266
224
 
295
253
    close_cached_file(&buffpek_pointers);
296
254
        /* Open cached file if it isn't open */
297
255
    if (! my_b_inited(outfile) &&
298
 
        open_cached_file(outfile,drizzle_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER,
 
256
        open_cached_file(outfile,mysql_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER,
299
257
                          MYF(MY_WME)))
300
258
      goto err;
301
 
    if (reinit_io_cache(outfile,internal::WRITE_CACHE,0L,0,0))
 
259
    if (reinit_io_cache(outfile,WRITE_CACHE,0L,0,0))
302
260
      goto err;
303
261
 
304
262
    /*
312
270
                        &tempfile))
313
271
      goto err;
314
272
    if (flush_io_cache(&tempfile) ||
315
 
        reinit_io_cache(&tempfile,internal::READ_CACHE,0L,0,0))
 
273
        reinit_io_cache(&tempfile,READ_CACHE,0L,0,0))
316
274
      goto err;
317
275
    if (merge_index(&param,(unsigned char*) sort_keys,buffpek,maxbuffer,&tempfile,
318
276
                    outfile))
343
301
    if (flush_io_cache(outfile))
344
302
      error=1;
345
303
    {
346
 
      internal::my_off_t save_pos=outfile->pos_in_file;
 
304
      my_off_t save_pos=outfile->pos_in_file;
347
305
      /* For following reads */
348
 
      if (reinit_io_cache(outfile,internal::READ_CACHE,0L,0,0))
 
306
      if (reinit_io_cache(outfile,READ_CACHE,0L,0,0))
349
307
        error=1;
350
308
      outfile->end_of_file=save_pos;
351
309
    }
354
312
    my_message(ER_FILSORT_ABORT, ER(ER_FILSORT_ABORT),
355
313
               MYF(ME_ERROR+ME_WAITTANG));
356
314
  else
357
 
    statistic_add(session->status_var.filesort_rows,
 
315
    statistic_add(thd->status_var.filesort_rows,
358
316
                  (uint32_t) records, &LOCK_status);
359
317
  *examined_rows= param.examined_rows;
360
318
  memcpy(&table->sort, &table_sort, sizeof(filesort_info_st));
361
 
  DRIZZLE_FILESORT_DONE(error, records);
362
 
  return (error ? HA_POS_ERROR : records);
 
319
  DRIZZLE_FILESORT_END();
 
320
  return(error ? HA_POS_ERROR : records);
363
321
} /* filesort */
364
322
 
365
323
 
366
 
void Table::filesort_free_buffers(bool full)
 
324
void filesort_free_buffers(Table *table, bool full)
367
325
{
368
 
  if (sort.record_pointers)
 
326
  if (table->sort.record_pointers)
369
327
  {
370
 
    free((unsigned char*) sort.record_pointers);
371
 
    sort.record_pointers=0;
 
328
    free((unsigned char*) table->sort.record_pointers);
 
329
    table->sort.record_pointers=0;
372
330
  }
373
331
  if (full)
374
332
  {
375
 
    if (sort.sort_keys )
 
333
    if (table->sort.sort_keys )
376
334
    {
377
 
      if ((unsigned char*) sort.sort_keys)
378
 
        free((unsigned char*) sort.sort_keys);
379
 
      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;
380
338
    }
381
 
    if (sort.buffpek)
 
339
    if (table->sort.buffpek)
382
340
    {
383
 
      if ((unsigned char*) sort.buffpek)
384
 
        free((unsigned char*) sort.buffpek);
385
 
      sort.buffpek= 0;
386
 
      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;
387
345
    }
388
346
  }
389
 
  if (sort.addon_buf)
 
347
  if (table->sort.addon_buf)
390
348
  {
391
 
    free((char *) sort.addon_buf);
392
 
    free((char *) sort.addon_field);
393
 
    sort.addon_buf=0;
394
 
    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;
395
353
  }
396
354
}
397
355
 
398
356
/** Make a array of string pointers. */
399
357
 
400
358
static char **make_char_array(char **old_pos, register uint32_t fields,
401
 
                              uint32_t length)
 
359
                              uint32_t length, myf my_flag)
402
360
{
403
361
  register char **pos;
404
362
  char *char_pos;
405
363
 
406
364
  if (old_pos ||
407
 
      (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)))
408
367
  {
409
368
    pos=old_pos; char_pos=((char*) (pos+fields)) -length;
410
369
    while (fields--) *(pos++) = (char_pos+= length);
416
375
 
417
376
/** Read 'count' number of buffer pointers into memory. */
418
377
 
419
 
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,
420
379
                                     unsigned char *buf)
421
380
{
422
381
  uint32_t length= sizeof(BUFFPEK)*count;
424
383
  if (count > UINT_MAX/sizeof(BUFFPEK))
425
384
    return 0; /* sizeof(BUFFPEK)*count will overflow */
426
385
  if (!tmp)
427
 
    tmp= (unsigned char *)malloc(length);
 
386
    tmp= (unsigned char *)my_malloc(length, MYF(MY_WME));
428
387
  if (tmp)
429
388
  {
430
 
    if (reinit_io_cache(buffpek_pointers,internal::READ_CACHE,0L,0,0) ||
 
389
    if (reinit_io_cache(buffpek_pointers,READ_CACHE,0L,0,0) ||
431
390
        my_b_read(buffpek_pointers, (unsigned char*) tmp, length))
432
391
    {
433
392
      free((char*) tmp);
475
434
    HA_POS_ERROR on error.
476
435
*/
477
436
 
478
 
static ha_rows find_all_keys(SORTPARAM *param, 
479
 
                             optimizer::SqlSelect *select,
 
437
static ha_rows find_all_keys(SORTPARAM *param, SQL_SELECT *select,
480
438
                             unsigned char **sort_keys,
481
 
                             internal::IO_CACHE *buffpek_pointers,
482
 
                             internal::IO_CACHE *tempfile, internal::IO_CACHE *indexfile)
 
439
                             IO_CACHE *buffpek_pointers,
 
440
                             IO_CACHE *tempfile, IO_CACHE *indexfile)
483
441
{
484
442
  int error,flag,quick_select;
485
443
  uint32_t idx,indexpos,ref_length;
486
444
  unsigned char *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];
487
 
  internal::my_off_t record;
 
445
  my_off_t record;
488
446
  Table *sort_form;
489
 
  Session *session= current_session;
490
 
  volatile Session::killed_state *killed= &session->killed;
491
 
  Cursor *file;
492
 
  MyBitmap *save_read_set, *save_write_set;
 
447
  THD *thd= current_thd;
 
448
  volatile THD::killed_state *killed= &thd->killed;
 
449
  handler *file;
 
450
  MY_BITMAP *save_read_set, *save_write_set;
493
451
 
494
452
  idx=indexpos=0;
495
453
  error=quick_select=0;
496
454
  sort_form=param->sort_form;
497
 
  file= sort_form->cursor;
 
455
  file=sort_form->file;
498
456
  ref_length=param->ref_length;
499
457
  ref_pos= ref_buff;
500
458
  quick_select=select && select->quick;
501
459
  record=0;
502
 
  flag= ((!indexfile && ! file->isOrdered())
 
460
  flag= ((!indexfile && file->ha_table_flags() & HA_REC_NOT_IN_SEQ)
503
461
         || quick_select);
504
462
  if (indexfile || flag)
505
463
    ref_pos= &file->ref[0];
509
467
    next_pos=(unsigned char*) 0;                        /* Find records in sequence */
510
468
    file->ha_rnd_init(1);
511
469
    file->extra_opt(HA_EXTRA_CACHE,
512
 
                    current_session->variables.read_buff_size);
 
470
                    current_thd->variables.read_buff_size);
513
471
  }
514
472
 
515
473
  READ_RECORD read_record_info;
517
475
  {
518
476
    if (select->quick->reset())
519
477
      return(HA_POS_ERROR);
520
 
    init_read_record(&read_record_info, current_session, select->quick->head,
 
478
    init_read_record(&read_record_info, current_thd, select->quick->head,
521
479
                     select, 1, 1);
522
480
  }
523
481
 
525
483
  save_read_set=  sort_form->read_set;
526
484
  save_write_set= sort_form->write_set;
527
485
  /* Set up temporary column read map for columns used by sort */
528
 
  sort_form->tmp_set.clearAll();
 
486
  bitmap_clear_all(&sort_form->tmp_set);
529
487
  /* Temporary set for register_used_fields and register_field_in_read_map */
530
488
  sort_form->read_set= &sort_form->tmp_set;
531
489
  register_used_fields(param);
549
507
    {
550
508
      if (indexfile)
551
509
      {
552
 
        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 */
553
511
        {
554
 
          error= errno ? errno : -1;            /* Abort */
 
512
          error= my_errno ? my_errno : -1;              /* Abort */
555
513
          break;
556
514
        }
557
515
        error=file->rnd_pos(sort_form->record[0],next_pos);
559
517
      else
560
518
      {
561
519
        error=file->rnd_next(sort_form->record[0]);
562
 
 
563
520
        if (!flag)
564
521
        {
565
 
          internal::my_store_ptr(ref_pos,ref_length,record); // Position to row
 
522
          my_store_ptr(ref_pos,ref_length,record); // Position to row
566
523
          record+= sort_form->s->db_record_offset;
567
524
        }
568
525
        else if (!error)
579
536
        (void) file->extra(HA_EXTRA_NO_CACHE);
580
537
        file->ha_rnd_end();
581
538
      }
582
 
      return(HA_POS_ERROR);
 
539
      return(HA_POS_ERROR);             /* purecov: inspected */
583
540
    }
584
541
    if (error == 0)
585
542
      param->examined_rows++;
597
554
    else
598
555
      file->unlock_row();
599
556
    /* It does not make sense to read more keys in case of a fatal error */
600
 
    if (session->is_error())
 
557
    if (thd->is_error())
601
558
      break;
602
559
  }
603
560
  if (quick_select)
615
572
      file->ha_rnd_end();
616
573
  }
617
574
 
618
 
  if (session->is_error())
 
575
  if (thd->is_error())
619
576
    return(HA_POS_ERROR);
620
 
 
 
577
  
621
578
  /* Signal we should use orignal column read and write maps */
622
579
  sort_form->column_bitmaps_set(save_read_set, save_write_set);
623
580
 
624
581
  if (error != HA_ERR_END_OF_FILE)
625
582
  {
626
 
    sort_form->print_error(error,MYF(ME_ERROR | ME_WAITTANG));
627
 
    return(HA_POS_ERROR);
 
583
    file->print_error(error,MYF(ME_ERROR | ME_WAITTANG)); /* purecov: inspected */
 
584
    return(HA_POS_ERROR);                       /* purecov: inspected */
628
585
  }
629
586
  if (indexpos && idx &&
630
587
      write_keys(param,sort_keys,idx,buffpek_pointers,tempfile))
631
 
    return(HA_POS_ERROR);
 
588
    return(HA_POS_ERROR);                       /* purecov: inspected */
632
589
  return(my_b_inited(tempfile) ?
633
590
              (ha_rows) (my_b_tell(tempfile)/param->rec_length) :
634
591
              idx);
659
616
 
660
617
static int
661
618
write_keys(SORTPARAM *param, register unsigned char **sort_keys, uint32_t count,
662
 
           internal::IO_CACHE *buffpek_pointers, internal::IO_CACHE *tempfile)
 
619
           IO_CACHE *buffpek_pointers, IO_CACHE *tempfile)
663
620
{
664
621
  size_t sort_length, rec_length;
665
622
  unsigned char **end;
667
624
 
668
625
  sort_length= param->sort_length;
669
626
  rec_length= param->rec_length;
670
 
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
 
627
  my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
671
628
  if (!my_b_inited(tempfile) &&
672
 
      open_cached_file(tempfile, drizzle_tmpdir, TEMP_PREFIX, DISK_BUFFER_SIZE,
 
629
      open_cached_file(tempfile, mysql_tmpdir, TEMP_PREFIX, DISK_BUFFER_SIZE,
673
630
                       MYF(MY_WME)))
674
 
    goto err;
 
631
    goto err;                                   /* purecov: inspected */
675
632
  /* check we won't have more buffpeks than we can possibly keep in memory */
676
633
  if (my_b_tell(buffpek_pointers) + sizeof(BUFFPEK) > (uint64_t)UINT_MAX)
677
634
    goto err;
678
635
  buffpek.file_pos= my_b_tell(tempfile);
679
636
  if ((ha_rows) count > param->max_rows)
680
 
    count=(uint32_t) param->max_rows;
 
637
    count=(uint32_t) param->max_rows;               /* purecov: inspected */
681
638
  buffpek.count=(ha_rows) count;
682
639
  for (end=sort_keys+count ; sort_keys != end ; sort_keys++)
683
640
    if (my_b_write(tempfile, (unsigned char*) *sort_keys, (uint32_t) rec_length))
721
678
{
722
679
  register Field *field;
723
680
  register SORT_FIELD *sort_field;
724
 
  size_t length;
 
681
  register uint32_t length;
725
682
 
726
683
  for (sort_field=param->local_sortorder ;
727
684
       sort_field != param->end ;
769
726
            memset(to-1, 0, sort_field->length+1);
770
727
          else
771
728
          {
 
729
            /* purecov: begin deadcode */
772
730
            /*
773
731
              This should only happen during extreme conditions if we run out
774
732
              of memory or have an item marked not null when it can be null.
776
734
            */
777
735
            assert(0);
778
736
            memset(to, 0, sort_field->length);  // Avoid crash
 
737
            /* purecov: end */
779
738
          }
780
739
          break;
781
740
        }
819
778
          int64_t value= item->val_int_result();
820
779
          if (maybe_null)
821
780
          {
822
 
            *to++=1;
 
781
            *to++=1;                            /* purecov: inspected */
823
782
            if (item->null_value)
824
783
            {
825
784
              if (maybe_null)
850
809
          if (maybe_null)
851
810
          {
852
811
            if (item->null_value)
853
 
            {
 
812
            { 
854
813
              memset(to, 0, sort_field->length+1);
855
814
              to++;
856
815
              break;
879
838
          break;
880
839
        }
881
840
      case ROW_RESULT:
882
 
      default:
 
841
      default: 
883
842
        // This case should never be choosen
884
843
        assert(0);
885
844
        break;
902
861
 
903
862
  if (param->addon_field)
904
863
  {
905
 
    /*
 
864
    /* 
906
865
      Save field values appended to sorted fields.
907
866
      First null bit indicators are appended then field values follow.
908
867
      In this implementation we use fixed layout for field values -
954
913
{
955
914
  register SORT_FIELD *sort_field;
956
915
  Table *table=param->sort_form;
 
916
  MY_BITMAP *bitmap= table->read_set;
957
917
 
958
918
  for (sort_field= param->local_sortorder ;
959
919
       sort_field != param->end ;
963
923
    if ((field= sort_field->field))
964
924
    {
965
925
      if (field->table == table)
966
 
        table->setReadSet(field->field_index);
 
926
      bitmap_set_bit(bitmap, field->field_index);
967
927
    }
968
928
    else
969
929
    {                                           // Item
977
937
    SORT_ADDON_FIELD *addonf= param->addon_field;
978
938
    Field *field;
979
939
    for ( ; (field= addonf->field) ; addonf++)
980
 
      table->setReadSet(field->field_index);
 
940
      bitmap_set_bit(bitmap, field->field_index);
981
941
  }
982
942
  else
983
943
  {
987
947
}
988
948
 
989
949
 
990
 
static bool save_index(SORTPARAM *param, unsigned char **sort_keys, uint32_t count,
 
950
static bool save_index(SORTPARAM *param, unsigned char **sort_keys, uint32_t count, 
991
951
                       filesort_info_st *table_sort)
992
952
{
993
953
  uint32_t offset,res_length;
994
954
  unsigned char *to;
995
955
 
996
 
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, param->sort_length);
 
956
  my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, param->sort_length);
997
957
  res_length= param->res_length;
998
958
  offset= param->rec_length-res_length;
999
959
  if ((ha_rows) count > param->max_rows)
1000
960
    count=(uint32_t) param->max_rows;
1001
 
  if (!(to= table_sort->record_pointers=
1002
 
        (unsigned char*) malloc(res_length*count)))
1003
 
    return(1);
 
961
  if (!(to= table_sort->record_pointers= 
 
962
        (unsigned char*) my_malloc(res_length*count, MYF(MY_WME))))
 
963
    return(1);                 /* purecov: inspected */
1004
964
  for (unsigned char **end= sort_keys+count ; sort_keys != end ; sort_keys++)
1005
965
  {
1006
966
    memcpy(to, *sort_keys+offset, res_length);
1013
973
/** Merge buffers to make < MERGEBUFF2 buffers. */
1014
974
 
1015
975
int merge_many_buff(SORTPARAM *param, unsigned char *sort_buffer,
1016
 
                    BUFFPEK *buffpek, uint32_t *maxbuffer, internal::IO_CACHE *t_file)
 
976
                    BUFFPEK *buffpek, uint32_t *maxbuffer, IO_CACHE *t_file)
1017
977
{
1018
978
  register uint32_t i;
1019
 
  internal::IO_CACHE t_file2,*from_file,*to_file,*temp;
 
979
  IO_CACHE t_file2,*from_file,*to_file,*temp;
1020
980
  BUFFPEK *lastbuff;
1021
981
 
1022
982
  if (*maxbuffer < MERGEBUFF2)
1023
 
    return(0);
 
983
    return(0);                          /* purecov: inspected */
1024
984
  if (flush_io_cache(t_file) ||
1025
 
      open_cached_file(&t_file2,drizzle_tmpdir,TEMP_PREFIX,DISK_BUFFER_SIZE,
 
985
      open_cached_file(&t_file2,mysql_tmpdir,TEMP_PREFIX,DISK_BUFFER_SIZE,
1026
986
                        MYF(MY_WME)))
1027
 
    return(1);
 
987
    return(1);                          /* purecov: inspected */
1028
988
 
1029
989
  from_file= t_file ; to_file= &t_file2;
1030
990
  while (*maxbuffer >= MERGEBUFF2)
1031
991
  {
1032
 
    if (reinit_io_cache(from_file,internal::READ_CACHE,0L,0,0))
 
992
    if (reinit_io_cache(from_file,READ_CACHE,0L,0,0))
1033
993
      goto cleanup;
1034
 
    if (reinit_io_cache(to_file,internal::WRITE_CACHE,0L,0,0))
 
994
    if (reinit_io_cache(to_file,WRITE_CACHE,0L,0,0))
1035
995
      goto cleanup;
1036
996
    lastbuff=buffpek;
1037
997
    for (i=0 ; i <= *maxbuffer-MERGEBUFF*3/2 ; i+=MERGEBUFF)
1042
1002
    }
1043
1003
    if (merge_buffers(param,from_file,to_file,sort_buffer,lastbuff++,
1044
1004
                      buffpek+i,buffpek+ *maxbuffer,0))
1045
 
      break;
 
1005
      break;                                    /* purecov: inspected */
1046
1006
    if (flush_io_cache(to_file))
1047
 
      break;
 
1007
      break;                                    /* purecov: inspected */
1048
1008
    temp=from_file; from_file=to_file; to_file=temp;
1049
1009
    setup_io_cache(from_file);
1050
1010
    setup_io_cache(to_file);
1069
1029
    (uint32_t)-1 if something goes wrong
1070
1030
*/
1071
1031
 
1072
 
uint32_t read_to_buffer(internal::IO_CACHE *fromfile, BUFFPEK *buffpek,
1073
 
                        uint32_t rec_length)
 
1032
uint32_t read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
 
1033
                    uint32_t rec_length)
1074
1034
{
1075
1035
  register uint32_t count;
1076
1036
  uint32_t length;
1077
1037
 
1078
 
  if ((count= (uint32_t) min((ha_rows) buffpek->max_keys,buffpek->count)))
 
1038
  if ((count=(uint32_t) cmin((ha_rows) buffpek->max_keys,buffpek->count)))
1079
1039
  {
1080
1040
    if (pread(fromfile->file,(unsigned char*) buffpek->base, (length= rec_length*count),buffpek->file_pos) == 0)
1081
 
      return((uint32_t) -1);
1082
 
 
1083
 
    buffpek->key= buffpek->base;
 
1041
      return((uint32_t) -1);                    /* purecov: inspected */
 
1042
    buffpek->key=buffpek->base;
1084
1043
    buffpek->file_pos+= length;                 /* New filepos */
1085
 
    buffpek->count-= count;
 
1044
    buffpek->count-=    count;
1086
1045
    buffpek->mem_count= count;
1087
1046
  }
1088
1047
  return (count*rec_length);
1089
1048
} /* read_to_buffer */
1090
1049
 
1091
1050
 
1092
 
class compare_functor
 
1051
/**
 
1052
  Put all room used by freed buffer to use in adjacent buffer.
 
1053
 
 
1054
  Note, that we can't simply distribute memory evenly between all buffers,
 
1055
  because new areas must not overlap with old ones.
 
1056
 
 
1057
  @param[in] queue      list of non-empty buffers, without freed buffer
 
1058
  @param[in] reuse      empty buffer
 
1059
  @param[in] key_length key length
 
1060
*/
 
1061
 
 
1062
void reuse_freed_buff(QUEUE *queue, BUFFPEK *reuse, uint32_t key_length)
1093
1063
{
1094
 
  qsort2_cmp key_compare;
1095
 
  void *key_compare_arg;
1096
 
  public:
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
 
1064
  unsigned char *reuse_end= reuse->base + reuse->max_keys * key_length;
 
1065
  for (uint32_t i= 0; i < queue->elements; ++i)
1100
1066
  {
1101
 
    int val= key_compare(key_compare_arg,
1102
 
                      &i->key, &j->key);
1103
 
    return (val >= 0);
 
1067
    BUFFPEK *bp= (BUFFPEK *) queue_element(queue, i);
 
1068
    if (bp->base + bp->max_keys * key_length == reuse->base)
 
1069
    {
 
1070
      bp->max_keys+= reuse->max_keys;
 
1071
      return;
 
1072
    }
 
1073
    else if (bp->base == reuse_end)
 
1074
    {
 
1075
      bp->base= reuse->base;
 
1076
      bp->max_keys+= reuse->max_keys;
 
1077
      return;
 
1078
    }
1104
1079
  }
1105
 
};
 
1080
  assert(0);
 
1081
}
1106
1082
 
1107
1083
 
1108
1084
/**
1123
1099
    other  error
1124
1100
*/
1125
1101
 
1126
 
int merge_buffers(SORTPARAM *param, internal::IO_CACHE *from_file,
1127
 
                  internal::IO_CACHE *to_file, unsigned char *sort_buffer,
 
1102
int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
 
1103
                  IO_CACHE *to_file, unsigned char *sort_buffer,
1128
1104
                  BUFFPEK *lastbuff, BUFFPEK *Fb, BUFFPEK *Tb,
1129
1105
                  int flag)
1130
1106
{
1133
1109
  size_t sort_length;
1134
1110
  uint32_t maxcount;
1135
1111
  ha_rows max_rows,org_max_rows;
1136
 
  internal::my_off_t to_start_filepos;
 
1112
  my_off_t to_start_filepos;
1137
1113
  unsigned char *strpos;
1138
1114
  BUFFPEK *buffpek;
 
1115
  QUEUE queue;
1139
1116
  qsort2_cmp cmp;
1140
1117
  void *first_cmp_arg;
1141
 
  volatile Session::killed_state *killed= &current_session->killed;
1142
 
  Session::killed_state not_killable;
 
1118
  volatile THD::killed_state *killed= &current_thd->killed;
 
1119
  THD::killed_state not_killable;
1143
1120
 
1144
 
  status_var_increment(current_session->status_var.filesort_merge_passes);
 
1121
  status_var_increment(current_thd->status_var.filesort_merge_passes);
1145
1122
  if (param->not_killable)
1146
1123
  {
1147
1124
    killed= &not_killable;
1148
 
    not_killable= Session::NOT_KILLED;
 
1125
    not_killable= THD::NOT_KILLED;
1149
1126
  }
1150
1127
 
1151
1128
  error=0;
1160
1137
 
1161
1138
  /* The following will fire if there is not enough space in sort_buffer */
1162
1139
  assert(maxcount!=0);
1163
 
 
 
1140
  
1164
1141
  if (param->unique_buff)
1165
1142
  {
1166
1143
    cmp= param->compare;
1168
1145
  }
1169
1146
  else
1170
1147
  {
1171
 
    cmp= internal::get_ptr_compare(sort_length);
 
1148
    cmp= get_ptr_compare(sort_length);
1172
1149
    first_cmp_arg= (void*) &sort_length;
1173
1150
  }
1174
 
  priority_queue<BUFFPEK *, vector<BUFFPEK *>, compare_functor > 
1175
 
    queue(compare_functor(cmp, first_cmp_arg));
 
1151
  if (init_queue(&queue, (uint32_t) (Tb-Fb)+1, offsetof(BUFFPEK,key), 0,
 
1152
                 (queue_compare) cmp, first_cmp_arg))
 
1153
    return(1);                                /* purecov: inspected */
1176
1154
  for (buffpek= Fb ; buffpek <= Tb ; buffpek++)
1177
1155
  {
1178
1156
    buffpek->base= strpos;
1180
1158
    strpos+= (uint32_t) (error= (int) read_to_buffer(from_file, buffpek,
1181
1159
                                                                         rec_length));
1182
1160
    if (error == -1)
1183
 
      goto err;
 
1161
      goto err;                                 /* purecov: inspected */
1184
1162
    buffpek->max_keys= buffpek->mem_count;      // If less data in buffers than expected
1185
 
    queue.push(buffpek);
 
1163
    queue_insert(&queue, (unsigned char*) buffpek);
1186
1164
  }
1187
1165
 
1188
1166
  if (param->unique_buff)
1189
1167
  {
1190
 
    /*
 
1168
    /* 
1191
1169
       Called by Unique::get()
1192
1170
       Copy the first argument to param->unique_buff for unique removal.
1193
1171
       Store it also in 'to_file'.
1195
1173
       This is safe as we know that there is always more than one element
1196
1174
       in each block to merge (This is guaranteed by the Unique:: algorithm
1197
1175
    */
1198
 
    buffpek= queue.top();
 
1176
    buffpek= (BUFFPEK*) queue_top(&queue);
1199
1177
    memcpy(param->unique_buff, buffpek->key, rec_length);
1200
1178
    if (my_b_write(to_file, (unsigned char*) buffpek->key, rec_length))
1201
1179
    {
1202
 
      error=1; goto err;
 
1180
      error=1; goto err;                        /* purecov: inspected */
1203
1181
    }
1204
1182
    buffpek->key+= rec_length;
1205
1183
    buffpek->mem_count--;
1206
1184
    if (!--max_rows)
1207
1185
    {
1208
 
      error= 0;
1209
 
      goto end;
 
1186
      error= 0;                                       /* purecov: inspected */
 
1187
      goto end;                                       /* purecov: inspected */
1210
1188
    }
1211
 
    /* Top element has been used */
1212
 
    queue.pop();
1213
 
    queue.push(buffpek);
 
1189
    queue_replaced(&queue);                        // Top element has been used
1214
1190
  }
1215
1191
  else
1216
1192
    cmp= 0;                                        // Not unique
1217
1193
 
1218
 
  while (queue.size() > 1)
 
1194
  while (queue.elements > 1)
1219
1195
  {
1220
1196
    if (*killed)
1221
1197
    {
1222
 
      error= 1; goto err;
 
1198
      error= 1; goto err;                        /* purecov: inspected */
1223
1199
    }
1224
1200
    for (;;)
1225
1201
    {
1226
 
      buffpek= queue.top();
 
1202
      buffpek= (BUFFPEK*) queue_top(&queue);
1227
1203
      if (cmp)                                        // Remove duplicates
1228
1204
      {
1229
1205
        if (!(*cmp)(first_cmp_arg, &(param->unique_buff),
1235
1211
      {
1236
1212
        if (my_b_write(to_file,(unsigned char*) buffpek->key, rec_length))
1237
1213
        {
1238
 
          error=1; goto err;
 
1214
          error=1; goto err;                        /* purecov: inspected */
1239
1215
        }
1240
1216
      }
1241
1217
      else
1242
1218
      {
1243
1219
        if (my_b_write(to_file, (unsigned char*) buffpek->key+offset, res_length))
1244
1220
        {
1245
 
          error=1; goto err;
 
1221
          error=1; goto err;                        /* purecov: inspected */
1246
1222
        }
1247
1223
      }
1248
1224
      if (!--max_rows)
1249
1225
      {
1250
 
        error= 0;
1251
 
        goto end;
 
1226
        error= 0;                               /* purecov: inspected */
 
1227
        goto end;                               /* purecov: inspected */
1252
1228
      }
1253
1229
 
1254
1230
    skip_duplicate:
1258
1234
        if (!(error= (int) read_to_buffer(from_file,buffpek,
1259
1235
                                          rec_length)))
1260
1236
        {
1261
 
          queue.pop();
 
1237
          queue_remove(&queue,0);
 
1238
          reuse_freed_buff(&queue, buffpek, rec_length);
1262
1239
          break;                        /* One buffer have been removed */
1263
1240
        }
1264
1241
        else if (error == -1)
1265
 
          goto err;
 
1242
          goto err;                        /* purecov: inspected */
1266
1243
      }
1267
 
      /* Top element has been replaced */
1268
 
      queue.pop();
1269
 
      queue.push(buffpek);
 
1244
      queue_replaced(&queue);              /* Top element has been replaced */
1270
1245
    }
1271
1246
  }
1272
 
  buffpek= queue.top();
 
1247
  buffpek= (BUFFPEK*) queue_top(&queue);
1273
1248
  buffpek->base= sort_buffer;
1274
1249
  buffpek->max_keys= param->keys;
1275
1250
 
1299
1274
      if (my_b_write(to_file,(unsigned char*) buffpek->key,
1300
1275
                     (rec_length*buffpek->mem_count)))
1301
1276
      {
1302
 
        error= 1; goto err;
 
1277
        error= 1; goto err;                        /* purecov: inspected */
1303
1278
      }
1304
1279
    }
1305
1280
    else
1309
1284
      for (end= strpos+buffpek->mem_count*rec_length ;
1310
1285
           strpos != end ;
1311
1286
           strpos+= rec_length)
1312
 
      {
 
1287
      {     
1313
1288
        if (my_b_write(to_file, (unsigned char *) strpos, res_length))
1314
1289
        {
1315
 
          error=1; goto err;
 
1290
          error=1; goto err;                        
1316
1291
        }
1317
1292
      }
1318
1293
    }
1321
1296
         != -1 && error != 0);
1322
1297
 
1323
1298
end:
1324
 
  lastbuff->count= min(org_max_rows-max_rows, param->max_rows);
 
1299
  lastbuff->count= cmin(org_max_rows-max_rows, param->max_rows);
1325
1300
  lastbuff->file_pos= to_start_filepos;
1326
1301
err:
 
1302
  delete_queue(&queue);
1327
1303
  return(error);
1328
1304
} /* merge_buffers */
1329
1305
 
1332
1308
 
1333
1309
static int merge_index(SORTPARAM *param, unsigned char *sort_buffer,
1334
1310
                       BUFFPEK *buffpek, uint32_t maxbuffer,
1335
 
                       internal::IO_CACHE *tempfile, internal::IO_CACHE *outfile)
 
1311
                       IO_CACHE *tempfile, IO_CACHE *outfile)
1336
1312
{
1337
1313
  if (merge_buffers(param,tempfile,outfile,sort_buffer,buffpek,buffpek,
1338
1314
                    buffpek+maxbuffer,1))
1339
 
    return(1);
 
1315
    return(1);                          /* purecov: inspected */
1340
1316
  return(0);
1341
1317
} /* merge_index */
1342
1318
 
1357
1333
/**
1358
1334
  Calculate length of sort key.
1359
1335
 
1360
 
  @param session                          Thread Cursor
 
1336
  @param thd                      Thread handler
1361
1337
  @param sortorder                Order of items to sort
1362
1338
  @param s_length                 Number of items to sort
1363
1339
  @param[out] multi_byte_charset Set to 1 if we are using multi-byte charset
1373
1349
*/
1374
1350
 
1375
1351
static uint32_t
1376
 
sortlength(Session *session, SORT_FIELD *sortorder, uint32_t s_length,
 
1352
sortlength(THD *thd, SORT_FIELD *sortorder, uint32_t s_length,
1377
1353
           bool *multi_byte_charset)
1378
1354
{
1379
1355
  register uint32_t length;
1407
1383
      switch (sortorder->result_type) {
1408
1384
      case STRING_RESULT:
1409
1385
        sortorder->length=sortorder->item->max_length;
1410
 
        set_if_smaller(sortorder->length,
1411
 
                       session->variables.max_sort_length);
 
1386
        set_if_smaller(sortorder->length, thd->variables.max_sort_length);
1412
1387
        if (use_strnxfrm((cs=sortorder->item->collation.collation)))
1413
 
        {
 
1388
        { 
1414
1389
          sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
1415
1390
          sortorder->need_strxnfrm= 1;
1416
1391
          *multi_byte_charset= 1;
1427
1402
        break;
1428
1403
      case DECIMAL_RESULT:
1429
1404
        sortorder->length=
1430
 
          my_decimal_get_binary_size(sortorder->item->max_length -
 
1405
          my_decimal_get_binary_size(sortorder->item->max_length - 
1431
1406
                                     (sortorder->item->decimals ? 1 : 0),
1432
1407
                                     sortorder->item->decimals);
1433
1408
        break;
1435
1410
        sortorder->length=sizeof(double);
1436
1411
        break;
1437
1412
      case ROW_RESULT:
1438
 
      default:
 
1413
      default: 
1439
1414
        // This case should never be choosen
1440
1415
        assert(0);
1441
1416
        break;
1443
1418
      if (sortorder->item->maybe_null)
1444
1419
        length++;                               // Place for NULL marker
1445
1420
    }
1446
 
    set_if_smaller(sortorder->length,
1447
 
                   (size_t)session->variables.max_sort_length);
 
1421
    set_if_smaller(sortorder->length, thd->variables.max_sort_length);
1448
1422
    length+=sortorder->length;
1449
1423
  }
1450
1424
  sortorder->field= (Field*) 0;                 // end marker
1458
1432
 
1459
1433
  The function first finds out what fields are used in the result set.
1460
1434
  Then it calculates the length of the buffer to store the values of
1461
 
  these fields together with the value of sort values.
 
1435
  these fields together with the value of sort values. 
1462
1436
  If the calculated length is not greater than max_length_for_sort_data
1463
1437
  the function allocates memory for an array of descriptors containing
1464
1438
  layouts for the values of the non-sorted fields in the buffer and
1465
1439
  fills them.
1466
1440
 
1467
 
  @param session                 Current thread
 
1441
  @param thd                 Current thread
1468
1442
  @param ptabfield           Array of references to the table fields
1469
1443
  @param sortlength          Total length of sorted fields
1470
1444
  @param[out] plength        Total length of appended fields
1480
1454
*/
1481
1455
 
1482
1456
static SORT_ADDON_FIELD *
1483
 
get_addon_fields(Session *session, Field **ptabfield, uint32_t sortlength, uint32_t *plength)
 
1457
get_addon_fields(THD *thd, Field **ptabfield, uint32_t sortlength, uint32_t *plength)
1484
1458
{
1485
1459
  Field **pfield;
1486
1460
  Field *field;
1488
1462
  uint32_t length= 0;
1489
1463
  uint32_t fields= 0;
1490
1464
  uint32_t null_fields= 0;
 
1465
  MY_BITMAP *read_set= (*ptabfield)->table->read_set;
1491
1466
 
1492
1467
  /*
1493
1468
    If there is a reference to a field in the query add it
1495
1470
    Note for future refinement:
1496
1471
    This this a too strong condition.
1497
1472
    Actually we need only the fields referred in the
1498
 
    result set. And for some of them it makes sense to use
 
1473
    result set. And for some of them it makes sense to use 
1499
1474
    the values directly from sorted fields.
1500
1475
  */
1501
1476
  *plength= 0;
1502
1477
 
1503
1478
  for (pfield= ptabfield; (field= *pfield) ; pfield++)
1504
1479
  {
1505
 
    if (!(field->isReadSet()))
 
1480
    if (!bitmap_is_set(read_set, field->field_index))
1506
1481
      continue;
1507
1482
    if (field->flags & BLOB_FLAG)
1508
1483
      return 0;
1510
1485
    if (field->maybe_null())
1511
1486
      null_fields++;
1512
1487
    fields++;
1513
 
  }
 
1488
  } 
1514
1489
  if (!fields)
1515
1490
    return 0;
1516
1491
  length+= (null_fields+7)/8;
1517
1492
 
1518
 
  if (length+sortlength > session->variables.max_length_for_sort_data ||
1519
 
      !(addonf= (SORT_ADDON_FIELD *) malloc(sizeof(SORT_ADDON_FIELD)*
1520
 
                                            (fields+1))))
 
1493
  if (length+sortlength > thd->variables.max_length_for_sort_data ||
 
1494
      !(addonf= (SORT_ADDON_FIELD *) my_malloc(sizeof(SORT_ADDON_FIELD)*
 
1495
                                               (fields+1), MYF(MY_WME))))
1521
1496
    return 0;
1522
1497
 
1523
1498
  *plength= length;
1525
1500
  null_fields= 0;
1526
1501
  for (pfield= ptabfield; (field= *pfield) ; pfield++)
1527
1502
  {
1528
 
    if (!(field->isReadSet()))
 
1503
    if (!bitmap_is_set(read_set, field->field_index))
1529
1504
      continue;
1530
1505
    addonf->field= field;
1531
1506
    addonf->offset= length;
1545
1520
    addonf++;
1546
1521
  }
1547
1522
  addonf->field= 0;     // Put end marker
1548
 
 
 
1523
  
1549
1524
  return (addonf-fields);
1550
1525
}
1551
1526
 
1565
1540
    void.
1566
1541
*/
1567
1542
 
1568
 
static void
 
1543
static void 
1569
1544
unpack_addon_fields(struct st_sort_addon_field *addon_field, unsigned char *buff)
1570
1545
{
1571
1546
  Field *field;
1630
1605
    }
1631
1606
  }
1632
1607
}
1633
 
 
1634
 
} /* namespace drizzled */