← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

  • Committer: Mark Atwood
  • Date: 2011-06-22 20:04:22 UTC
  • mfrom: (2318.6.39 rf)
  • Revision ID: me@mark.atwood.name-20110622200422-609npl456o0e5p32
merge lp:~olafvdspek/drizzle/refactor13

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
574
574
  sz= sizeof(optimizer::KeyField) *
575
575
      (((session->lex().current_select->cond_count+1)*2 +
576
576
        session->lex().current_select->between_count)*m+1);
577
 
  key_fields= (optimizer::KeyField*) session->getMemRoot()->allocate(sz);
 
577
  key_fields= (optimizer::KeyField*) session->mem.alloc(sz);
578
578
  and_level= 0;
579
579
  field= end= key_fields;
580
580
 
999
999
  j->ref.key_parts=keyparts;
1000
1000
  j->ref.key_length=length;
1001
1001
  j->ref.key=(int) key;
1002
 
  if (!(j->ref.key_buff= (unsigned char*) session->calloc(ALIGN_SIZE(length)*2)) ||
1003
 
      !(j->ref.key_copy= (StoredKey**) session->getMemRoot()->allocate((sizeof(StoredKey*) *
1004
 
               (keyparts+1)))) ||
1005
 
      !(j->ref.items=    (Item**) session->getMemRoot()->allocate(sizeof(Item*)*keyparts)) ||
1006
 
      !(j->ref.cond_guards= (bool**) session->getMemRoot()->allocate(sizeof(uint*)*keyparts)))
1007
 
  {
1008
 
    return(true);
1009
 
  }
 
1002
  j->ref.key_buff= (unsigned char*) session->mem.calloc(ALIGN_SIZE(length)*2);
 
1003
  j->ref.key_copy= (StoredKey**) session->mem.alloc((sizeof(StoredKey*) * (keyparts+1)));
 
1004
  j->ref.items=    (Item**) session->mem.alloc(sizeof(Item*)*keyparts);
 
1005
  j->ref.cond_guards= (bool**) session->mem.alloc(sizeof(uint*)*keyparts);
1010
1006
  j->ref.key_buff2=j->ref.key_buff+ALIGN_SIZE(length);
1011
1007
  j->ref.key_err=1;
1012
1008
  j->ref.null_rejecting= 0;
4939
4935
    return(0);
4940
4936
  for (Order *ord= join->order; ord; ord= ord->next)
4941
4937
    length++;
4942
 
  if (!(join->sortorder= make_unireg_sortorder(order, &length, join->sortorder)))
4943
 
  {
4944
 
    return(-1);
4945
 
  }
4946
 
 
 
4938
  join->sortorder= make_unireg_sortorder(order, &length, join->sortorder);
4947
4939
  table->sort.io_cache= new internal::io_cache_st;
4948
4940
  table->status=0;                              // May be wrong if quick_select
4949
4941
 
5188
5180
  return 1;
5189
5181
}
5190
5182
 
5191
 
SortField *make_unireg_sortorder(Order *order, uint32_t *length, SortField *sortorder)
 
5183
SortField* make_unireg_sortorder(Order* order, uint32_t* length, SortField* sortorder)
5192
5184
{
5193
 
  uint32_t count;
5194
5185
  SortField *sort,*pos;
5195
5186
 
5196
 
  count=0;
 
5187
  uint32_t count= 0;
5197
5188
  for (Order *tmp = order; tmp; tmp=tmp->next)
5198
5189
    count++;
5199
 
  if (!sortorder)
5200
 
    sortorder= (SortField*) memory::sql_alloc(sizeof(SortField) *
5201
 
                                       (max(count, *length) + 1));
 
5190
  if (not sortorder)
 
5191
    sortorder= (SortField*) memory::sql_alloc(sizeof(SortField) * (max(count, *length) + 1));
5202
5192
  pos= sort= sortorder;
5203
5193
 
5204
 
  if (!pos)
5205
 
    return 0;
5206
 
 
5207
 
  for (;order;order=order->next,pos++)
 
5194
  for (; order; order= order->next,pos++)
5208
5195
  {
5209
5196
    Item *item= order->item[0]->real_item();
5210
5197
    pos->field= 0; pos->item= 0;
5221
5208
    pos->reverse=! order->asc;
5222
5209
  }
5223
5210
  *length=count;
5224
 
  return(sort);
 
5211
  return sort;
5225
5212
}
5226
5213
 
5227
5214
/*
5340
5327
    uint32_t count= (uint32_t) order_item->val_int();
5341
5328
    if (!count || count > fields.size())
5342
5329
    {
5343
 
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
5344
 
               order_item->full_name(), session->where());
 
5330
      my_error(ER_BAD_FIELD_ERROR, MYF(0), order_item->full_name(), session->where());
5345
5331
      return true;
5346
5332
    }
5347
5333
    order->item= ref_pointer_array + count - 1;
5351
5337
    return false;
5352
5338
  }
5353
5339
  /* Lookup the current GROUP/order_st field in the SELECT clause. */
5354
 
  select_item= find_item_in_list(session, order_item, fields, &counter,
5355
 
                                 REPORT_EXCEPT_NOT_FOUND, &resolution);
 
5340
  select_item= find_item_in_list(session, order_item, fields, &counter, REPORT_EXCEPT_NOT_FOUND, &resolution);
5356
5341
  if (!select_item)
5357
5342
    return true; /* The item is not unique, or some other error occured. */
5358
5343
 
5461
5446
                Order *order)
5462
5447
{
5463
5448
  session->setWhere("order clause");
5464
 
  for (; order; order=order->next)
 
5449
  for (; order; order= order->next)
5465
5450
  {
5466
 
    if (find_order_in_list(session, ref_pointer_array, tables, order, fields,
5467
 
                           all_fields, false))
 
5451
    if (find_order_in_list(session, ref_pointer_array, tables, order, fields, all_fields, false))
5468
5452
      return 1;
5469
5453
  }
5470
5454
  return 0;
5601
5585
                                bool *all_order_by_fields_used)
5602
5586
{
5603
5587
  List<Item>::iterator li(fields.begin());
5604
 
  Item *item;
5605
5588
  Order *order,*group,**prev;
5606
5589
 
5607
5590
  *all_order_by_fields_used= 1;
5608
 
  while ((item=li++))
 
5591
  while (Item* item=li++)
5609
5592
    item->marker=0;                     /* Marker that field is not used */
5610
5593
 
5611
5594
  prev= &group;  group=0;
5613
5596
  {
5614
5597
    if (order->in_field_list)
5615
5598
    {
5616
 
      Order *ord=(Order*) session->getMemRoot()->duplicate((char*) order,sizeof(Order));
5617
 
      if (!ord)
5618
 
        return 0;
 
5599
      Order *ord=(Order*) session->mem.memdup(order,sizeof(Order));
5619
5600
      *prev=ord;
5620
5601
      prev= &ord->next;
5621
5602
      (*ord->item)->marker=1;
5625
5606
  }
5626
5607
 
5627
5608
  li= fields.begin();
5628
 
  while ((item=li++))
 
5609
  while (Item* item=li++)
5629
5610
  {
5630
5611
    if (!item->const_item() && !item->with_sum_func && !item->marker)
5631
5612
    {
5638
5619
        if ((*ord_iter->item)->eq(item, 1))
5639
5620
          goto next_item;
5640
5621
 
5641
 
      Order *ord=(Order*) session->calloc(sizeof(Order));
5642
 
      if (!ord)
5643
 
        return 0;
 
5622
      Order *ord=(Order*) session->mem.calloc(sizeof(Order));
5644
5623
 
5645
5624
      /*
5646
5625
        We have here only field_list (not all_field_list), so we can use
6261
6240
{
6262
6241
  /* List is reversed => we should reverse it before using */
6263
6242
  List<TableList>::iterator ti(tables->begin());
6264
 
  TableList **table= (TableList **)session->getMemRoot()->allocate(sizeof(TableList*) *
6265
 
                                                tables->size());
6266
 
  if (table == 0)
6267
 
    return;  // out of memory
 
6243
  TableList **table= (TableList **)session->mem.alloc(sizeof(TableList*) * tables->size());
6268
6244
 
6269
6245
  for (TableList **t= table + (tables->size() - 1); t >= table; t--)
6270
6246
    *t= ti++;