← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_select.cc

Big merge.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_select.cc
59
59
#include "drizzled/optimizer/sargable_param.h"
60
60
#include "drizzled/optimizer/key_use.h"
61
61
#include "drizzled/optimizer/range.h"
 
62
#include "drizzled/optimizer/quick_range_select.h"
62
63
 
63
64
using namespace std;
64
65
using namespace drizzled;
475
476
  Create JoinTableS, make a guess about the table types,
476
477
  Approximate how many records will be used in each table
477
478
*****************************************************************************/
478
 
ha_rows get_quick_record_count(Session *session, optimizer::SQL_SELECT *select, Table *table, const key_map *keys,ha_rows limit)
 
479
ha_rows get_quick_record_count(Session *session, optimizer::SqlSelect *select, Table *table, const key_map *keys,ha_rows limit)
479
480
{
480
481
  int error;
481
482
  if (check_stack_overrun(session, STACK_MIN_SIZE, NULL))
4791
4792
  int order_direction;
4792
4793
  uint32_t used_key_parts;
4793
4794
  Table *table=tab->table;
4794
 
  optimizer::SQL_SELECT *select= tab->select;
 
4795
  optimizer::SqlSelect *select= tab->select;
4795
4796
  key_map usable_keys;
4796
 
  optimizer::QUICK_SELECT_I *save_quick= NULL;
 
4797
  optimizer::QuickSelectInterface *save_quick= NULL;
4797
4798
 
4798
4799
  /*
4799
4800
    Keys disabled by ALTER Table ... DISABLE KEYS should have already
4833
4834
      by clustered PK values.
4834
4835
    */
4835
4836
 
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)
 
4837
    if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE ||
 
4838
        quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
4839
        quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT)
4839
4840
      return(0);
4840
4841
    ref_key=       select->quick->index;
4841
4842
    ref_key_parts= select->quick->used_key_parts;
4885
4886
        else
4886
4887
        {
4887
4888
          /*
4888
 
            The range optimizer constructed QUICK_RANGE for ref_key, and
 
4889
            The range optimizer constructed QuickRange for ref_key, and
4889
4890
            we want to use instead new_ref_key as the index. We can't
4890
4891
            just change the index of the quick select, because this may
4891
4892
            result in an incosistent QUICK_SELECT object. Below we
5154
5155
      */
5155
5156
      if (! select->quick->reverse_sorted())
5156
5157
      {
5157
 
        optimizer::QUICK_SELECT_DESC *tmp= NULL;
 
5158
        optimizer::QuickSelectDescending *tmp= NULL;
5158
5159
        bool error= false;
5159
5160
        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)
 
5161
        if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE ||
 
5162
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT ||
 
5163
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
5164
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX)
5164
5165
        {
5165
5166
          tab->limit= 0;
5166
5167
          select->quick= save_quick;
5167
 
          return(0);                   // Use filesort
 
5168
          return 0; // Use filesort
5168
5169
        }
5169
5170
 
5170
5171
        /* order_st BY range_key DESC */
5171
 
        tmp= new optimizer::QUICK_SELECT_DESC((optimizer::QUICK_RANGE_SELECT*)(select->quick),
5172
 
                                              used_key_parts, &error);
5173
 
        if (!tmp || error)
 
5172
        tmp= new optimizer::QuickSelectDescending((optimizer::QuickRangeSelect*)(select->quick),
 
5173
                                                  used_key_parts, 
 
5174
                                                  &error);
 
5175
        if (! tmp || error)
5174
5176
        {
5175
5177
          delete tmp;
5176
 
                select->quick= save_quick;
5177
 
                tab->limit= 0;
5178
 
          return(0);            // Reverse sort not supported
 
5178
          select->quick= save_quick;
 
5179
          tab->limit= 0;
 
5180
          return 0; // Reverse sort not supported
5179
5181
        }
5180
5182
        select->quick=tmp;
5181
5183
      }
5195
5197
  }
5196
5198
  else if (select && select->quick)
5197
5199
    select->quick->sorted= 1;
5198
 
  return(1);
 
5200
  return 1;
5199
5201
}
5200
5202
 
5201
5203
/*
5231
5233
  uint32_t length= 0;
5232
5234
  ha_rows examined_rows;
5233
5235
  Table *table;
5234
 
  optimizer::SQL_SELECT *select= NULL;
 
5236
  optimizer::SqlSelect *select= NULL;
5235
5237
  JoinTable *tab;
5236
5238
 
5237
5239
  if (join->tables == join->const_tables)
5248
5250
  */
5249
5251
  if ((order != join->group_list ||
5250
5252
       !(join->select_options & SELECT_BIG_RESULT) ||
5251
 
       (select && select->quick && (select->quick->get_type() == optimizer::QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX))) &&
 
5253
       (select && select->quick && (select->quick->get_type() == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX))) &&
5252
5254
      test_if_skip_sort_order(tab,order,select_limit,0,
5253
5255
                              is_order_by ?  &table->keys_in_use_for_order_by :
5254
5256
                              &table->keys_in_use_for_group_by))
6685
6687
      if (tab->type == AM_ALL && tab->select && tab->select->quick)
6686
6688
      {
6687
6689
        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))
 
6690
        if ((quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE) ||
 
6691
            (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT) ||
 
6692
            (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION))
6691
6693
          tab->type = AM_INDEX_MERGE;
6692
6694
        else
6693
6695
          tab->type = AM_RANGE;
6815
6817
      if ((tab->type == AM_NEXT || tab->type == AM_CONST) &&
6816
6818
          table->covering_keys.test(tab->index))
6817
6819
        key_read=1;
6818
 
      if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_ROR_INTERSECT &&
 
6820
      if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT &&
6819
6821
          !((optimizer::QUICK_ROR_INTERSECT_SELECT*)tab->select->quick)->need_to_fetch_row)
6820
6822
        key_read=1;
6821
6823
 
6847
6849
        else if (tab->select && tab->select->quick)
6848
6850
          keyno = tab->select->quick->index;
6849
6851
 
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)
 
6852
        if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_UNION ||
 
6853
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_ROR_INTERSECT ||
 
6854
            quick_type == optimizer::QuickSelectInterface::QS_TYPE_INDEX_MERGE)
6853
6855
        {
6854
6856
          extra.append(STRING_WITH_LEN("; Using "));
6855
6857
          tab->select->quick->add_info_string(&extra);
6888
6890
        }
6889
6891
        if (key_read)
6890
6892
        {
6891
 
          if (quick_type == optimizer::QUICK_SELECT_I::QS_TYPE_GROUP_MIN_MAX)
 
6893
          if (quick_type == optimizer::QuickSelectInterface::QS_TYPE_GROUP_MIN_MAX)
6892
6894
            extra.append(STRING_WITH_LEN("; Using index for group-by"));
6893
6895
          else
6894
6896
            extra.append(STRING_WITH_LEN("; Using index"));