← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Performed numerous style cleanups in range.[cc,h].

Mainly involved:
 * renaming classes to not be all upper case
 * initializing variables when they are declared
 * correcting wrong indentation
 * removing tabs where I found them
 * correctly lining up paramaters in function calls and delcarations

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
475
475
  Create JoinTableS, make a guess about the table types,
476
476
  Approximate how many records will be used in each table
477
477
*****************************************************************************/
478
 
ha_rows get_quick_record_count(Session *session, optimizer::SQL_SELECT *select, Table *table, const key_map *keys,ha_rows limit)
 
478
ha_rows get_quick_record_count(Session *session, optimizer::SqlSelect *select, Table *table, const key_map *keys,ha_rows limit)
479
479
{
480
480
  int error;
481
481
  if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))
4791
4791
  int order_direction;
4792
4792
  uint32_t used_key_parts;
4793
4793
  Table *table=tab->table;
4794
 
  optimizer::SQL_SELECT *select= tab->select;
 
4794
  optimizer::SqlSelect *select= tab->select;
4795
4795
  key_map usable_keys;
4796
 
  optimizer::QUICK_SELECT_I *save_quick= NULL;
 
4796
  optimizer::QuickSelectInterface *save_quick= NULL;
4797
4797
 
4798
4798
  /*
4799
4799
    Keys disabled by ALTER Table ... DISABLE KEYS should have already
4833
4833
      by clustered PK values.
4834
4834
    */
4835
4835
 
4836
 
    if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_INDEX_MERGE ||
4837
 
        quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_UNION ||
4838
 
        quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT)
 
4836
    if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE ||
 
4837
        quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
4838
        quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT)
4839
4839
      return(0);
4840
4840
    ref_key=       select->quick->index;
4841
4841
    ref_key_parts= select->quick->used_key_parts;
5157
5157
        optimizer::QUICK_SELECT_DESC *tmp= NULL;
5158
5158
        bool error= false;
5159
5159
        int quick_type= select->quick->get_type();
5160
 
        if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_INDEX_MERGE ||
5161
 
            quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT ||
5162
 
            quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_UNION ||
5163
 
            quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX)
 
5160
        if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE ||
 
5161
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT ||
 
5162
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
5163
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX)
5164
5164
        {
5165
5165
          tab->limit= 0;
5166
5166
          select->quick= save_quick;
5231
5231
  uint32_t length= 0;
5232
5232
  ha_rows examined_rows;
5233
5233
  Table *table;
5234
 
  optimizer::SQL_SELECT *select= NULL;
 
5234
  optimizer::SqlSelect *select= NULL;
5235
5235
  JoinTable *tab;
5236
5236
 
5237
5237
  if (join->tables == join->const_tables)
5248
5248
  */
5249
5249
  if ((order != join->group_list ||
5250
5250
       !(join->select_options & SELECT_BIG_RESULT) ||
5251
 
       (select && select->quick && (select->quick->get_type() == optimizer::QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))) &&
 
5251
       (select && select->quick && (select->quick->get_type() == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX))) &&
5252
5252
      test_if_skip_sort_order(tab,order,select_limit,0,
5253
5253
                              is_order_by ?  &table->keys_in_use_for_order_by :
5254
5254
                              &table->keys_in_use_for_group_by))
6685
6685
      if (tab->type == AM_ALL && tab->select && tab->select->quick)
6686
6686
      {
6687
6687
        quick_type= tab->select->quick->get_type();
6688
 
        if ((quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_INDEX_MERGE) ||
6689
 
            (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT) ||
6690
 
            (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_UNION))
 
6688
        if ((quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE) ||
 
6689
            (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT) ||
 
6690
            (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION))
6691
6691
          tab->type = AM_INDEX_MERGE;
6692
6692
        else
6693
6693
          tab->type = AM_RANGE;
6815
6815
      if ((tab->type == AM_NEXT || tab->type == AM_CONST) &&
6816
6816
          table->covering_keys.test(tab->index))
6817
6817
        key_read=1;
6818
 
      if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT &&
 
6818
      if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT &&
6819
6819
          !((optimizer::QUICK_ROR_INTERSECT_SELECT*)tab->select->quick)->need_to_fetch_row)
6820
6820
        key_read=1;
6821
6821
 
6847
6847
        else if (tab->select && tab->select->quick)
6848
6848
          keyno = tab->select->quick->index;
6849
6849
 
6850
 
        if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_UNION ||
6851
 
            quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT ||
6852
 
            quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_INDEX_MERGE)
 
6850
        if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
6851
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT ||
 
6852
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE)
6853
6853
        {
6854
6854
          extra.append(STRING_WITH_LEN("; Using "));
6855
6855
          tab->select->quick->add_info_string(&extra);
6888
6888
        }
6889
6889
        if (key_read)
6890
6890
        {
6891
 
          if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX)
 
6891
          if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX)
6892
6892
            extra.append(STRING_WITH_LEN("; Using index for group-by"));
6893
6893
          else
6894
6894
            extra.append(STRING_WITH_LEN("; Using index"));