← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Merged Drizzle's Trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
853
853
  Field **f_ptr,*field;
854
854
 
855
855
  null_fields= blobs= fields= rec_length=0;
856
 
  for (f_ptr=join_tab->table->field ; (field= *f_ptr) ; f_ptr++)
 
856
  for (f_ptr=join_tab->table->getFields() ; (field= *f_ptr) ; f_ptr++)
857
857
  {
858
858
    if (field->isReadSet())
859
859
    {
3221
3221
    if (table->group && tmp_tbl->sum_func_count &&
3222
3222
        !tmp_tbl->precomputed_group_by)
3223
3223
    {
3224
 
      if (table->s->keys)
 
3224
      if (table->getShare()->sizeKeys())
3225
3225
      {
3226
3226
        end_select= end_update;
3227
3227
      }
3288
3288
    table->cursor->extra(HA_EXTRA_WRITE_CACHE);
3289
3289
    table->emptyRecord();
3290
3290
    if (table->group && join->tmp_table_param.sum_func_count &&
3291
 
        table->s->keys && !table->cursor->inited)
 
3291
        table->getShare()->sizeKeys() && !table->cursor->inited)
3292
3292
      table->cursor->startIndexScan(0, 0);
3293
3293
  }
3294
3294
  /* Set up select_end */
3680
3680
  if (table->status & STATUS_GARBAGE)           // If first read
3681
3681
  {
3682
3682
    if ((error=table->cursor->read_first_row(table->record[0],
3683
 
                                           table->s->primary_key)))
 
3683
                                           table->getShare()->primary_key)))
3684
3684
    {
3685
3685
      if (error != HA_ERR_END_OF_FILE)
3686
3686
        return table->report_error(error);
3942
3942
  return join_init_read_record(tab);
3943
3943
}
3944
3944
 
3945
 
int rr_sequential(ReadRecord *info);
3946
3945
int init_read_record_seq(JoinTable *tab)
3947
3946
{
3948
 
  tab->read_record.read_record= rr_sequential;
 
3947
  tab->read_record.init_reard_record_sequential();
 
3948
 
3949
3949
  if (tab->read_record.cursor->startTableScan(1))
3950
3950
    return 1;
3951
3951
  return (*tab->read_record.read_record)(&tab->read_record);
4526
4526
      */
4527
4527
      if (!on_primary_key &&
4528
4528
          (table->cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&
4529
 
          table->s->primary_key != MAX_KEY)
 
4529
          table->getShare()->primary_key != MAX_KEY)
4530
4530
      {
4531
4531
        on_primary_key= true;
4532
 
        key_part= table->key_info[table->s->primary_key].key_part;
4533
 
        key_part_end=key_part+table->key_info[table->s->primary_key].key_parts;
4534
 
        const_key_parts=table->const_key_parts[table->s->primary_key];
 
4532
        key_part= table->key_info[table->getShare()->primary_key].key_part;
 
4533
        key_part_end=key_part+table->key_info[table->getShare()->primary_key].key_parts;
 
4534
        const_key_parts=table->const_key_parts[table->getShare()->primary_key];
4535
4535
 
4536
4536
        for (; const_key_parts & 1 ; const_key_parts>>= 1)
4537
4537
          key_part++;
4614
4614
  KeyPartInfo *ref_key_part= table->key_info[ref].key_part;
4615
4615
  KeyPartInfo *ref_key_part_end= ref_key_part + ref_key_parts;
4616
4616
 
4617
 
  for (nr= 0 ; nr < table->s->keys ; nr++)
 
4617
  for (nr= 0 ; nr < table->getShare()->sizeKeys() ; nr++)
4618
4618
  {
4619
4619
    if (usable_keys->test(nr) &&
4620
4620
        table->key_info[nr].key_length < min_length &&
4663
4663
*/
4664
4664
bool list_contains_unique_index(Table *table, bool (*find_func) (Field *, void *), void *data)
4665
4665
{
4666
 
  for (uint32_t keynr= 0; keynr < table->s->keys; keynr++)
 
4666
  for (uint32_t keynr= 0; keynr < table->getShare()->sizeKeys(); keynr++)
4667
4667
  {
4668
 
    if (keynr == table->s->primary_key ||
 
4668
    if (keynr == table->getShare()->primary_key ||
4669
4669
         (table->key_info[keynr].flags & HA_NOSAME))
4670
4670
    {
4671
4671
      KeyInfo *keyinfo= table->key_info + keynr;
4964
4964
      fanout*= cur_pos.getFanout(); // fanout is always >= 1
4965
4965
    }
4966
4966
 
4967
 
    for (nr=0; nr < table->s->keys ; nr++)
 
4967
    for (nr=0; nr < table->getShare()->sizeKeys() ; nr++)
4968
4968
    {
4969
4969
      int direction;
4970
4970
      if (keys.test(nr) &&
4971
4971
          (direction= test_if_order_by_key(order, table, nr, &used_key_parts)))
4972
4972
      {
4973
 
        bool is_covering= table->covering_keys.test(nr) || (nr == table->s->primary_key && table->cursor->primary_key_is_clustered());
 
4973
        bool is_covering= table->covering_keys.test(nr) || (nr == table->getShare()->primary_key && table->cursor->primary_key_is_clustered());
4974
4974
 
4975
4975
        /*
4976
4976
          Don't use an index scan with ORDER BY without limit.
5252
5252
    goto err;
5253
5253
 
5254
5254
  table->sort.io_cache= new internal::IO_CACHE;
5255
 
  memset(table->sort.io_cache, 0, sizeof(internal::IO_CACHE));
5256
5255
  table->status=0;                              // May be wrong if quick_select
5257
5256
 
5258
5257
  // If table has a range, move it to select
5290
5289
    }
5291
5290
  }
5292
5291
 
5293
 
  if (table->s->tmp_table)
 
5292
  if (table->getShare()->tmp_table)
5294
5293
    table->cursor->info(HA_STATUS_VARIABLE);    // Get record count
5295
5294
  table->sort.found_records=filesort(session, table,join->sortorder, length,
5296
5295
                                     select, filesort_limit, 0,
5323
5322
  char *org_record,*new_record;
5324
5323
  unsigned char *record;
5325
5324
  int error;
5326
 
  uint32_t reclength= table->s->reclength-offset;
 
5325
  uint32_t reclength= table->getShare()->getRecordLength() - offset;
5327
5326
 
5328
5327
  org_record=(char*) (record=table->record[0])+offset;
5329
5328
  new_record=(char*) table->record[1]+offset;
5416
5415
  int error;
5417
5416
  Cursor *cursor= table->cursor;
5418
5417
  uint32_t extra_length= ALIGN_SIZE(key_length)-key_length;
5419
 
  uint32_t *field_lengths,*field_length;
 
5418
  uint32_t *field_length;
5420
5419
  HASH hash;
5421
 
  std::vector<unsigned char>key_buffer;
 
5420
  std::vector<unsigned char> key_buffer;
 
5421
  std::vector<uint32_t> field_lengths;
5422
5422
 
5423
5423
  key_buffer.resize((key_length + extra_length) * (long) cursor->stats.records);
5424
 
 
5425
 
  field_lengths= (uint32_t *)std::malloc(field_count * sizeof(*field_lengths));
5426
 
 
5427
 
  if (field_lengths == NULL)
5428
 
    return(1);
 
5424
  field_lengths.resize(field_count);
5429
5425
 
5430
5426
  {
5431
5427
    Field **ptr;
5432
5428
    uint32_t total_length= 0;
5433
5429
 
5434
 
    for (ptr= first_field, field_length=field_lengths ; *ptr ; ptr++)
 
5430
    for (ptr= first_field, field_length= &field_lengths[0] ; *ptr ; ptr++)
5435
5431
    {
5436
5432
      uint32_t length= (*ptr)->sort_length();
5437
5433
      (*field_length++)= length;
5445
5441
  if (hash_init(&hash, &my_charset_bin, (uint32_t) cursor->stats.records, 0,
5446
5442
                key_length, (hash_get_key) 0, 0, 0))
5447
5443
  {
5448
 
    free((char*) field_lengths);
5449
5444
    return(1);
5450
5445
  }
5451
5446
 
5477
5472
 
5478
5473
    /* copy fields to key buffer */
5479
5474
    org_key_pos= key_pos;
5480
 
    field_length=field_lengths;
 
5475
    field_length= &field_lengths[0];
5481
5476
    for (Field **ptr= first_field ; *ptr ; ptr++)
5482
5477
    {
5483
5478
      (*ptr)->sort_string(key_pos,*field_length);
5494
5489
      (void) my_hash_insert(&hash, org_key_pos);
5495
5490
    key_pos+=extra_length;
5496
5491
  }
5497
 
  free((char*) field_lengths);
5498
5492
  hash_free(&hash);
5499
5493
  cursor->extra(HA_EXTRA_NO_CACHE);
5500
5494
  (void) cursor->endTableScan();
5501
5495
  return(0);
5502
5496
 
5503
5497
err:
5504
 
  free((char*) field_lengths);
5505
5498
  hash_free(&hash);
5506
5499
  cursor->extra(HA_EXTRA_NO_CACHE);
5507
5500
  (void) cursor->endTableScan();
5740
5733
      push_warning_printf(session, DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_NON_UNIQ_ERROR,
5741
5734
                          ER(ER_NON_UNIQ_ERROR),
5742
5735
                          ((Item_ident*) order_item)->field_name,
5743
 
                          current_session->where);
 
5736
                          session->where);
5744
5737
    }
5745
5738
  }
5746
5739
 
6594
6587
void Select_Lex::print(Session *session, String *str, enum_query_type query_type)
6595
6588
{
6596
6589
  /* QQ: session may not be set for sub queries, but this should be fixed */
6597
 
  if (!session)
6598
 
    session= current_session;
 
6590
  assert(session);
6599
6591
 
6600
6592
  str->append(STRING_WITH_LEN("select "));
6601
6593