← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

  • Committer: Lee Bieber
  • Date: 2011-02-24 03:20:47 UTC
  • mfrom: (2196.1.4 build)
  • Revision ID: kalebral@gmail.com-20110224032047-avmw06iwww3m73cw
Merge Andrew - 723653: Docs day first pass fixes 
Merge Brian - Puts back in support for COM_KILL, Also adds back in the INTERACTIVE flag, and creates a DD to track sessions/check on usage
Merge Olaf - Use List::size()

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
146
146
                      select_lex->with_wild,
147
147
                      select_lex->item_list,
148
148
                      select_lex->where,
149
 
                      select_lex->order_list.elements +
150
 
                      select_lex->group_list.elements,
 
149
                      select_lex->order_list.size() +
 
150
                      select_lex->group_list.size(),
151
151
                      (Order*) select_lex->order_list.first,
152
152
                      (Order*) select_lex->group_list.first,
153
153
                      select_lex->having,
226
226
    */
227
227
    if (ref_pointer_array && !ref->found_in_select_list)
228
228
    {
229
 
      int el= all_fields.elements;
 
229
      int el= all_fields.size();
230
230
      ref_pointer_array[el]= item;
231
231
      /* Add the field item to the select list of the current select. */
232
232
      all_fields.push_front(item);
641
641
      (e.g. if there is a key(a,b,c) but only b < 5 (or a=2 and c < 3) is
642
642
      used in the query, we drop the partial key parts from consideration).
643
643
  */
644
 
  if (keyuse->elements)
 
644
  if (keyuse->size())
645
645
  {
646
646
    optimizer::KeyUse key_end,*prev,*save_pos,*use;
647
647
 
648
 
    internal::my_qsort(keyuse->buffer,keyuse->elements,sizeof(optimizer::KeyUse),
 
648
    internal::my_qsort(keyuse->buffer,keyuse->size(),sizeof(optimizer::KeyUse),
649
649
                       (qsort_cmp) sort_keyuse);
650
650
 
651
651
    memset(&key_end, 0, sizeof(key_end)); /* Add for easy testing */
657
657
    {
658
658
      uint32_t i;
659
659
 
660
 
      for (i= 0; i < keyuse->elements-1; i++, use++)
 
660
      for (i= 0; i < keyuse->size()-1; i++, use++)
661
661
      {
662
662
        if (! use->getUsedTables() && use->getOptimizeFlags() != KEY_OPTIMIZE_REF_OR_NULL)
663
663
          use->getTable()->const_key_parts[use->getKey()]|= use->getKeypartMap();
700
700
                                                  0, 
701
701
                                                  optimizer::KeyUse*);
702
702
 
703
 
  for (end= keyuse+ keyuse_array->elements ; keyuse < end ; keyuse++)
 
703
  for (end= keyuse+ keyuse_array->size() ; keyuse < end ; keyuse++)
704
704
  {
705
705
    table_map map;
706
706
    /*
775
775
  else
776
776
    return;
777
777
 
778
 
  if (indexed_fields.elements == 0)
 
778
  if (indexed_fields.size() == 0)
779
779
    return;
780
780
 
781
781
  /* Intersect the keys of all group fields. */
1880
1880
     */
1881
1881
    if (check_equality(session, cond, &cond_equal, &eq_list))
1882
1882
    {
1883
 
      int n= cond_equal.current_level.elements + eq_list.elements;
 
1883
      int n= cond_equal.current_level.size() + eq_list.size();
1884
1884
      if (n == 0)
1885
1885
        return new Item_int((int64_t) 1,1);
1886
1886
      else if (n == 1)
2281
2281
      }
2282
2282
    }
2283
2283
    if (cond->type() == Item::COND_ITEM &&
2284
 
        !((Item_cond*)cond)->argument_list()->elements)
 
2284
        !((Item_cond*)cond)->argument_list()->size())
2285
2285
      cond= new Item_int((int32_t)cond->val_bool());
2286
2286
 
2287
2287
  }
2464
2464
      if (item->name == in_additional_cond)
2465
2465
      {
2466
2466
        li.remove();
2467
 
        if (cnd->argument_list()->elements == 1)
 
2467
        if (cnd->argument_list()->size() == 1)
2468
2468
          return cnd->argument_list()->head();
2469
2469
        return conds;
2470
2470
      }
2655
2655
      join->cur_embedding_map |= next_emb->getNestedJoin()->nj_map;
2656
2656
    }
2657
2657
 
2658
 
    if (next_emb->getNestedJoin()->join_list.elements !=
 
2658
    if (next_emb->getNestedJoin()->join_list.size() !=
2659
2659
        next_emb->getNestedJoin()->counter_)
2660
2660
      break;
2661
2661
 
2762
2762
    if (should_fix_fields)
2763
2763
      cond->update_used_tables();
2764
2764
 
2765
 
    if (! ((Item_cond*) cond)->argument_list()->elements || *cond_value != Item::COND_OK)
 
2765
    if (! ((Item_cond*) cond)->argument_list()->size() || *cond_value != Item::COND_OK)
2766
2766
      return (COND*) NULL;
2767
2767
 
2768
 
    if (((Item_cond*) cond)->argument_list()->elements == 1)
 
2768
    if (((Item_cond*) cond)->argument_list()->size() == 1)
2769
2769
    {                                           
2770
2770
      /* Argument list contains only one element, so reduce it so a single item, then remove list */
2771
2771
      item= ((Item_cond*) cond)->argument_list()->head();
4067
4067
        if (fix)
4068
4068
          new_cond->argument_list()->push_back(fix);
4069
4069
      }
4070
 
      switch (new_cond->argument_list()->elements) 
 
4070
      switch (new_cond->argument_list()->size()) 
4071
4071
      {
4072
4072
        case 0:
4073
4073
          return (COND*) 0;                     // Always true
5363
5363
  if (order_item->type() == Item::INT_ITEM && order_item->basic_const_item())
5364
5364
  {                                             /* Order by position */
5365
5365
    uint32_t count= (uint32_t) order_item->val_int();
5366
 
    if (!count || count > fields.elements)
 
5366
    if (!count || count > fields.size())
5367
5367
    {
5368
5368
      my_error(ER_BAD_FIELD_ERROR, MYF(0),
5369
5369
               order_item->full_name(), session->where());
5465
5465
       session->is_fatal_error))
5466
5466
    return true; /* Wrong field. */
5467
5467
 
5468
 
  uint32_t el= all_fields.elements;
 
5468
  uint32_t el= all_fields.size();
5469
5469
  all_fields.push_front(order_item); /* Add new field to field list. */
5470
5470
  ref_pointer_array[el]= order_item;
5471
5471
  order->item= ref_pointer_array + el;
5534
5534
  if (!order)
5535
5535
    return 0;                           /* Everything is ok */
5536
5536
 
5537
 
  uint32_t org_fields=all_fields.elements;
 
5537
  uint32_t org_fields=all_fields.size();
5538
5538
 
5539
5539
  session->setWhere("group statement");
5540
5540
  for (ord= order; ord; ord= ord->next)
5607
5607
      cur_pos_in_select_list++;
5608
5608
    }
5609
5609
  }
5610
 
  if (org_fields != all_fields.elements)
 
5610
  if (org_fields != all_fields.size())
5611
5611
    *hidden_group_fields=1;                     // group fields is not used
5612
5612
  return 0;
5613
5613
}
5750
5750
  int idx= -1,i;
5751
5751
  Cached_item *buff;
5752
5752
 
5753
 
  for (i=(int) list.elements-1 ; (buff=li++) ; i--)
 
5753
  for (i=(int) list.size()-1 ; (buff=li++) ; i--)
5754
5754
  {
5755
5755
    if (buff->cmp())
5756
5756
      idx=i;
5801
5801
  res_all_fields.clear();
5802
5802
  List<Item>::iterator itr(res_all_fields.begin());
5803
5803
  List<Item> extra_funcs;
5804
 
  uint32_t i, border= all_fields.elements - elements;
 
5804
  uint32_t i, border= all_fields.size() - elements;
5805
5805
 
5806
5806
  if (param->field_count &&
5807
5807
      !(copy=param->copy_field= new CopyField[param->field_count]))
5893
5893
        goto err;
5894
5894
    }
5895
5895
    res_all_fields.push_back(pos);
5896
 
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
 
5896
    ref_pointer_array[((i < border)? all_fields.size()-i-1 : i-border)]=
5897
5897
      pos;
5898
5898
  }
5899
5899
  param->copy_field_end= copy;
5966
5966
  res_selected_fields.clear();
5967
5967
  res_all_fields.clear();
5968
5968
 
5969
 
  uint32_t i, border= all_fields.elements - elements;
 
5969
  uint32_t i, border= all_fields.size() - elements;
5970
5970
  for (i= 0; (item= it++); i++)
5971
5971
  {
5972
5972
    Field *field;
6005
6005
        item_field= item;
6006
6006
    }
6007
6007
    res_all_fields.push_back(item_field);
6008
 
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
 
6008
    ref_pointer_array[((i < border)? all_fields.size()-i-1 : i-border)]=
6009
6009
      item_field;
6010
6010
  }
6011
6011
 
6044
6044
  res_selected_fields.clear();
6045
6045
  res_all_fields.clear();
6046
6046
 
6047
 
  uint32_t i, border= all_fields.elements - elements;
 
6047
  uint32_t i, border= all_fields.size() - elements;
6048
6048
  for (i= 0; (item= it++); i++)
6049
6049
  {
6050
6050
    res_all_fields.push_back(new_item= item->get_tmp_table_item(session));
6051
 
    ref_pointer_array[((i < border)? all_fields.elements-i-1 : i-border)]=
 
6051
    ref_pointer_array[((i < border)? all_fields.size()-i-1 : i-border)]=
6052
6052
      new_item;
6053
6053
  }
6054
6054
 
6294
6294
  /* List is reversed => we should reverse it before using */
6295
6295
  List<TableList>::iterator ti(tables->begin());
6296
6296
  TableList **table= (TableList **)session->getMemRoot()->allocate(sizeof(TableList*) *
6297
 
                                                tables->elements);
 
6297
                                                tables->size());
6298
6298
  if (table == 0)
6299
6299
    return;  // out of memory
6300
6300
 
6301
 
  for (TableList **t= table + (tables->elements - 1); t >= table; t--)
 
6301
  for (TableList **t= table + (tables->size() - 1); t >= table; t--)
6302
6302
    *t= ti++;
6303
 
  assert(tables->elements >= 1);
6304
 
  print_table_array(session, str, table, table + tables->elements);
 
6303
  assert(tables->size() >= 1);
 
6304
  print_table_array(session, str, table, table + tables->size());
6305
6305
}
6306
6306
 
6307
6307
void Select_Lex::print(Session *session, String *str, enum_query_type query_type)
6344
6344
    from clause
6345
6345
    @todo support USING/FORCE/IGNORE index
6346
6346
  */
6347
 
  if (table_list.elements)
 
6347
  if (table_list.size())
6348
6348
  {
6349
6349
    str->append(STRING_WITH_LEN(" from "));
6350
6350
    /* go through join tree */
6373
6373
  }
6374
6374
 
6375
6375
  // group by & olap
6376
 
  if (group_list.elements)
 
6376
  if (group_list.size())
6377
6377
  {
6378
6378
    str->append(STRING_WITH_LEN(" group by "));
6379
6379
    print_order(str, (Order *) group_list.first, query_type);
6404
6404
      str->append(having_value != Item::COND_FALSE ? "1" : "0");
6405
6405
  }
6406
6406
 
6407
 
  if (order_list.elements)
 
6407
  if (order_list.size())
6408
6408
  {
6409
6409
    str->append(STRING_WITH_LEN(" order by "));
6410
6410
    print_order(str, (Order *) order_list.first, query_type);