← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/optimizer/quick_index_merge_select.cc

Merge Padraig

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/optimizer/quick_index_merge_select.cc
20
20
#include "drizzled/server_includes.h"
21
21
#include "drizzled/session.h"
22
22
#include "drizzled/records.h"
 
23
#include "drizzled/util/functors.h"
23
24
#include "drizzled/optimizer/quick_range_select.h"
24
25
#include "drizzled/optimizer/quick_index_merge_select.h"
25
26
 
 
27
#include <vector>
 
28
 
 
29
using namespace std;
26
30
using namespace drizzled;
27
31
 
28
32
extern "C"
72
76
  }
73
77
  else
74
78
  {
75
 
    return quick_selects.push_back(quick_sel_range);
 
79
    quick_selects.push_back(quick_sel_range);
76
80
  }
77
 
  return 0;
 
81
  return false;
78
82
}
79
83
 
80
84
optimizer::QuickIndexMergeSelect::~QuickIndexMergeSelect()
81
85
{
82
 
  List_iterator_fast<optimizer::QuickRangeSelect> quick_it(quick_selects);
83
 
  optimizer::QuickRangeSelect* quick;
84
 
  quick_it.rewind();
85
 
  while ((quick= quick_it++))
 
86
  for (vector<optimizer::QuickRangeSelect *>::iterator it= quick_selects.begin();
 
87
       it != quick_selects.end();
 
88
       ++it)
86
89
  {
87
 
    quick->cursor= NULL;
 
90
    (*it)->cursor= NULL;
88
91
  }
89
 
  quick_selects.delete_elements();
 
92
  for_each(quick_selects.begin(),
 
93
           quick_selects.end(),
 
94
           DeletePtr());
 
95
  quick_selects.clear();
90
96
  delete pk_quick_select;
91
97
  free_root(&alloc,MYF(0));
92
98
  return;
95
101
 
96
102
int optimizer::QuickIndexMergeSelect::read_keys_and_merge()
97
103
{
98
 
  List_iterator_fast<optimizer::QuickRangeSelect> cur_quick_it(quick_selects);
99
 
  optimizer::QuickRangeSelect* cur_quick;
 
104
  vector<optimizer::QuickRangeSelect *>::iterator it= quick_selects.begin();
 
105
  optimizer::QuickRangeSelect *cur_quick= NULL;
100
106
  int result;
101
 
  Unique *unique;
 
107
  Unique *unique= NULL;
102
108
  Cursor *cursor= head->cursor;
103
109
 
104
110
  cursor->extra(HA_EXTRA_KEYREAD);
105
111
  head->prepare_for_position();
106
112
 
107
 
  cur_quick_it.rewind();
108
 
  cur_quick= cur_quick_it++;
 
113
  cur_quick= *it;
 
114
  ++it;
109
115
  assert(cur_quick != 0);
110
116
 
111
117
  /*
116
122
    return 0;
117
123
 
118
124
  unique= new Unique(refpos_order_cmp,
119
 
                     (void *)cursor,
 
125
                     (void *) cursor,
120
126
                     cursor->ref_length,
121
127
                     session->variables.sortbuff_size);
122
 
  if (!unique)
 
128
  if (! unique)
123
129
    return 0;
124
130
  for (;;)
125
131
  {
126
132
    while ((result= cur_quick->get_next()) == HA_ERR_END_OF_FILE)
127
133
    {
128
134
      cur_quick->range_end();
129
 
      cur_quick= cur_quick_it++;
130
 
      if (!cur_quick)
 
135
      if (it == quick_selects.end())
 
136
      {
 
137
        break;
 
138
      }
 
139
      cur_quick= *it;
 
140
      ++it;
 
141
      if (! cur_quick)
131
142
        break;
132
143
 
133
144
      if (cur_quick->cursor->inited != Cursor::NONE)
154
165
      continue;
155
166
 
156
167
    cur_quick->cursor->position(cur_quick->record);
157
 
    result= unique->unique_add((char*)cur_quick->cursor->ref);
 
168
    result= unique->unique_add((char*) cur_quick->cursor->ref);
158
169
    if (result)
159
170
      return 0;
160
171
 
199
210
 
200
211
bool optimizer::QuickIndexMergeSelect::is_keys_used(const MyBitmap *fields)
201
212
{
202
 
  optimizer::QuickRangeSelect *quick= NULL;
203
 
  List_iterator_fast<QuickRangeSelect> it(quick_selects);
204
 
  while ((quick= it++))
 
213
  for (vector<optimizer::QuickRangeSelect *>::iterator it= quick_selects.begin();
 
214
       it != quick_selects.end();
 
215
       ++it)
205
216
  {
206
 
    if (is_key_used(head, quick->index, fields))
 
217
    if (is_key_used(head, (*it)->index, fields))
 
218
    {
207
219
      return 1;
 
220
    }
208
221
  }
209
222
  return 0;
210
223
}
212
225
 
213
226
void optimizer::QuickIndexMergeSelect::add_info_string(String *str)
214
227
{
215
 
  optimizer::QuickRangeSelect *quick= NULL;
216
228
  bool first= true;
217
 
  List_iterator_fast<optimizer::QuickRangeSelect> it(quick_selects);
218
229
  str->append(STRING_WITH_LEN("sort_union("));
219
 
  while ((quick= it++))
 
230
  for (vector<optimizer::QuickRangeSelect *>::iterator it= quick_selects.begin();
 
231
       it != quick_selects.end();
 
232
       ++it)
220
233
  {
221
234
    if (! first)
222
235
      str->append(',');
223
236
    else
224
237
      first= false;
225
 
    quick->add_info_string(str);
 
238
    (*it)->add_info_string(str);
226
239
  }
227
240
  if (pk_quick_select)
228
241
  {
237
250
                                                            String *used_lengths)
238
251
{
239
252
  char buf[64];
240
 
  uint32_t length;
 
253
  uint32_t length= 0;
241
254
  bool first= true;
242
 
  optimizer::QuickRangeSelect *quick= NULL;
243
255
 
244
 
  List_iterator_fast<optimizer::QuickRangeSelect> it(quick_selects);
245
 
  while ((quick= it++))
 
256
  for (vector<optimizer::QuickRangeSelect *>::iterator it= quick_selects.begin();
 
257
       it != quick_selects.end();
 
258
       ++it)
246
259
  {
247
260
    if (first)
248
261
      first= false;
252
265
      used_lengths->append(',');
253
266
    }
254
267
 
255
 
    KEY *key_info= head->key_info + quick->index;
 
268
    KEY *key_info= head->key_info + (*it)->index;
256
269
    key_names->append(key_info->name);
257
 
    length= int64_t2str(quick->max_used_key_length, buf, 10) - buf;
 
270
    length= int64_t2str((*it)->max_used_key_length, buf, 10) - buf;
258
271
    used_lengths->append(buf, length);
259
272
  }
260
273
  if (pk_quick_select)