← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/filesort.cc

  • Committer: Brian Aker
  • Date: 2010-08-03 04:19:05 UTC
  • mto: This revision was merged to the branch mainline in revision 1684.
  • Revision ID: brian@gaz-20100803041905-xkgqsndtrqf2xetg
Remove call for using special new for a cursor.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/filesort.cc
56
56
                                             uint32_t count,
57
57
                                             unsigned char *buf);
58
58
 
59
 
static ha_rows find_all_keys(SORTPARAM *param,
 
59
static ha_rows find_all_keys(Session *session,
 
60
                             SORTPARAM *param,
60
61
                             optimizer::SqlSelect *select,
61
62
                             unsigned char * *sort_keys, 
62
63
                             internal::IO_CACHE *buffer_file,
148
149
  TableList *tab= table->pos_in_table_list;
149
150
  Item_subselect *subselect= tab ? tab->containing_subselect() : 0;
150
151
 
151
 
  DRIZZLE_FILESORT_START(table->s->getSchemaName(), table->s->getTableName());
 
152
  DRIZZLE_FILESORT_START(table->getShare()->getSchemaName(), table->getShare()->getTableName());
152
153
 
153
154
  /*
154
155
   Release InnoDB's adaptive hash index latch (if holding) before
180
181
      Get the descriptors of all fields whose values are appended
181
182
      to sorted fields and get its total length in param.spack_length.
182
183
    */
183
 
    param.addon_field= get_addon_fields(session, table->field,
 
184
    param.addon_field= get_addon_fields(session, table->getFields(),
184
185
                                        param.sort_length,
185
186
                                        &param.addon_length);
186
187
  }
260
261
    my_error(ER_OUT_OF_SORTMEMORY,MYF(ME_ERROR+ME_WAITTANG));
261
262
    goto err;
262
263
  }
263
 
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir,TEMP_PREFIX,
 
264
  if (open_cached_file(&buffpek_pointers,drizzle_tmpdir.c_str(),TEMP_PREFIX,
264
265
                       DISK_BUFFER_SIZE, MYF(MY_WME)))
265
266
    goto err;
266
267
 
267
268
  param.keys--;                         /* TODO: check why we do this */
268
269
  param.sort_form= table;
269
270
  param.end=(param.local_sortorder=sortorder)+s_length;
270
 
  if ((records=find_all_keys(&param,select,sort_keys, &buffpek_pointers,
 
271
  if ((records=find_all_keys(session, &param,select,sort_keys, &buffpek_pointers,
271
272
                             &tempfile, selected_records_file)) ==
272
273
      HA_POS_ERROR)
273
274
    goto err;
295
296
    close_cached_file(&buffpek_pointers);
296
297
        /* Open cached file if it isn't open */
297
298
    if (! my_b_inited(outfile) &&
298
 
        open_cached_file(outfile,drizzle_tmpdir,TEMP_PREFIX,READ_RECORD_BUFFER,
 
299
        open_cached_file(outfile,drizzle_tmpdir.c_str(),TEMP_PREFIX,READ_RECORD_BUFFER,
299
300
                          MYF(MY_WME)))
300
301
      goto err;
301
302
    if (reinit_io_cache(outfile,internal::WRITE_CACHE,0L,0,0))
328
329
      free(param.tmp_buffer);
329
330
  if (!subselect || !subselect->is_uncacheable())
330
331
  {
331
 
    if ((unsigned char*) sort_keys)
332
 
      free((unsigned char*) sort_keys);
 
332
    free(sort_keys);
333
333
    table_sort.sort_keys= 0;
334
 
    if ((unsigned char*) buffpek)
335
 
      free((unsigned char*) buffpek);
 
334
    free(buffpek);
336
335
    table_sort.buffpek= 0;
337
336
    table_sort.buffpek_len= 0;
338
337
  }
475
474
    HA_POS_ERROR on error.
476
475
*/
477
476
 
478
 
static ha_rows find_all_keys(SORTPARAM *param, 
 
477
static ha_rows find_all_keys(Session *session,
 
478
                             SORTPARAM *param, 
479
479
                             optimizer::SqlSelect *select,
480
480
                             unsigned char **sort_keys,
481
481
                             internal::IO_CACHE *buffpek_pointers,
486
486
  unsigned char *ref_pos,*next_pos,ref_buff[MAX_REFLENGTH];
487
487
  internal::my_off_t record;
488
488
  Table *sort_form;
489
 
  Session *session= current_session;
490
489
  volatile Session::killed_state *killed= &session->killed;
491
490
  Cursor *file;
492
491
  MyBitmap *save_read_set, *save_write_set;
507
506
  if (! indexfile && ! quick_select)
508
507
  {
509
508
    next_pos=(unsigned char*) 0;                        /* Find records in sequence */
510
 
    file->ha_rnd_init(1);
 
509
    file->startTableScan(1);
511
510
    file->extra_opt(HA_EXTRA_CACHE,
512
 
                    current_session->variables.read_buff_size);
 
511
                    session->variables.read_buff_size);
513
512
  }
514
513
 
515
 
  READ_RECORD read_record_info;
 
514
  ReadRecord read_record_info;
516
515
  if (quick_select)
517
516
  {
518
517
    if (select->quick->reset())
519
518
      return(HA_POS_ERROR);
520
 
    init_read_record(&read_record_info, current_session, select->quick->head,
521
 
                     select, 1, 1);
 
519
 
 
520
    read_record_info.init_read_record(session, select->quick->head, select, 1, 1);
522
521
  }
523
522
 
524
523
  /* Remember original bitmaps */
543
542
        error= HA_ERR_END_OF_FILE;
544
543
        break;
545
544
      }
546
 
      file->position(sort_form->record[0]);
 
545
      file->position(sort_form->getInsertRecord());
547
546
    }
548
547
    else                                        /* Not quick-select */
549
548
    {
554
553
          error= errno ? errno : -1;            /* Abort */
555
554
          break;
556
555
        }
557
 
        error=file->rnd_pos(sort_form->record[0],next_pos);
 
556
        error=file->rnd_pos(sort_form->getInsertRecord(),next_pos);
558
557
      }
559
558
      else
560
559
      {
561
 
        error=file->rnd_next(sort_form->record[0]);
 
560
        error=file->rnd_next(sort_form->getInsertRecord());
562
561
 
563
562
        if (!flag)
564
563
        {
565
564
          internal::my_store_ptr(ref_pos,ref_length,record); // Position to row
566
 
          record+= sort_form->s->db_record_offset;
 
565
          record+= sort_form->getShare()->db_record_offset;
567
566
        }
568
567
        else if (!error)
569
 
          file->position(sort_form->record[0]);
 
568
          file->position(sort_form->getInsertRecord());
570
569
      }
571
570
      if (error && error != HA_ERR_RECORD_DELETED)
572
571
        break;
577
576
      if (!indexfile && !quick_select)
578
577
      {
579
578
        (void) file->extra(HA_EXTRA_NO_CACHE);
580
 
        file->ha_rnd_end();
 
579
        file->endTableScan();
581
580
      }
582
581
      return(HA_POS_ERROR);
583
582
    }
606
605
      index_merge quick select uses table->sort when retrieving rows, so free
607
606
      resoures it has allocated.
608
607
    */
609
 
    end_read_record(&read_record_info);
 
608
    read_record_info.end_read_record();
610
609
  }
611
610
  else
612
611
  {
613
612
    (void) file->extra(HA_EXTRA_NO_CACHE);      /* End cacheing of records */
614
613
    if (!next_pos)
615
 
      file->ha_rnd_end();
 
614
      file->endTableScan();
616
615
  }
617
616
 
618
617
  if (session->is_error())
669
668
  rec_length= param->rec_length;
670
669
  internal::my_string_ptr_sort((unsigned char*) sort_keys, (uint32_t) count, sort_length);
671
670
  if (!my_b_inited(tempfile) &&
672
 
      open_cached_file(tempfile, drizzle_tmpdir, TEMP_PREFIX, DISK_BUFFER_SIZE,
 
671
      open_cached_file(tempfile, drizzle_tmpdir.c_str(), TEMP_PREFIX, DISK_BUFFER_SIZE,
673
672
                       MYF(MY_WME)))
674
673
    goto err;
675
674
  /* check we won't have more buffpeks than we can possibly keep in memory */
962
961
    Field *field;
963
962
    if ((field= sort_field->field))
964
963
    {
965
 
      if (field->table == table)
 
964
      if (field->getTable() == table)
966
965
        table->setReadSet(field->field_index);
967
966
    }
968
967
    else
1022
1021
  if (*maxbuffer < MERGEBUFF2)
1023
1022
    return(0);
1024
1023
  if (flush_io_cache(t_file) ||
1025
 
      open_cached_file(&t_file2,drizzle_tmpdir,TEMP_PREFIX,DISK_BUFFER_SIZE,
 
1024
      open_cached_file(&t_file2,drizzle_tmpdir.c_str(),TEMP_PREFIX,DISK_BUFFER_SIZE,
1026
1025
                        MYF(MY_WME)))
1027
1026
    return(1);
1028
1027