Commit d8efc3b1 authored by Sergey Petrunya's avatar Sergey Petrunya

DS-MRR improvements: address review feedback for R3 version of the patch

parent ac8a79b9
...@@ -2177,7 +2177,8 @@ public: ...@@ -2177,7 +2177,8 @@ public:
TRUE if the engine supports virtual columns TRUE if the engine supports virtual columns
*/ */
virtual bool check_if_supported_virtual_columns(void) { return FALSE;} virtual bool check_if_supported_virtual_columns(void) { return FALSE;}
TABLE* get_table() { return table; }
protected: protected:
/* deprecated, don't use in new engines */ /* deprecated, don't use in new engines */
inline void ha_statistic_increment(ulong SSV::*offset) const { } inline void ha_statistic_increment(ulong SSV::*offset) const { }
...@@ -2370,7 +2371,6 @@ private: ...@@ -2370,7 +2371,6 @@ private:
virtual int rename_partitions(const char *path) virtual int rename_partitions(const char *path)
{ return HA_ERR_WRONG_COMMAND; } { return HA_ERR_WRONG_COMMAND; }
friend class ha_partition; friend class ha_partition;
friend class DsMrr_impl;
public: public:
/* XXX to be removed, see ha_partition::partition_ht() */ /* XXX to be removed, see ha_partition::partition_ht() */
virtual handlerton *partition_ht() const virtual handlerton *partition_ht() const
......
...@@ -214,7 +214,6 @@ handler::multi_range_read_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param, ...@@ -214,7 +214,6 @@ handler::multi_range_read_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param,
DBUG_RETURN(0); DBUG_RETURN(0);
} }
/** /**
Get next record in MRR scan Get next record in MRR scan
...@@ -230,7 +229,7 @@ handler::multi_range_read_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param, ...@@ -230,7 +229,7 @@ handler::multi_range_read_init(RANGE_SEQ_IF *seq_funcs, void *seq_init_param,
int handler::multi_range_read_next(char **range_info) int handler::multi_range_read_next(char **range_info)
{ {
int UNINIT_VAR(result); int result= HA_ERR_END_OF_FILE;
int range_res; int range_res;
DBUG_ENTER("handler::multi_range_read_next"); DBUG_ENTER("handler::multi_range_read_next");
...@@ -284,6 +283,416 @@ scan_it_again: ...@@ -284,6 +283,416 @@ scan_it_again:
} }
/***** MRR_impl classes ****************************************************/
int Mrr_simple_index_reader::get_next(char **range_info)
{
while (!(res= h->handler::multi_range_read_next(range_info)))
{
KEY_MULTI_RANGE *curr_range= &h->handler::mrr_cur_range;
if (!h->mrr_funcs.skip_index_tuple ||
!h->mrr_funcs.skip_index_tuple(h->mrr_iter, curr_range->ptr))
break;
}
return res;
}
int Mrr_simple_index_reader::init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges,
uint mode, Buffer_manager *buf_manager_arg)
{
HANDLER_BUFFER no_buffer = {NULL, NULL, NULL};
h= h_arg;
return h->handler::multi_range_read_init(seq_funcs, seq_init_param, n_ranges,
mode, &no_buffer);
}
/**
DS-MRR/CPK: multi_range_read_next() function
@param range_info OUT identifier of range that the returned record belongs to
@note
This function walks over key buffer and does index reads, i.e. it produces
{current_record, range_id} pairs.
The function has the same call contract like multi_range_read_next()'s.
We actually iterate over nested sequences:
- a disjoint sequence of index ranges
- each range has multiple records
- each record goes into multiple identical ranges.
@retval 0 OK, next record was successfully read
@retval HA_ERR_END_OF_FILE End of records
@retval Other Some other error
*/
int Mrr_ordered_index_reader::get_next(char **range_info_arg)
{
DBUG_ENTER("Mrr_ordered_index_reader::get_next");
while (1)
{
bool have_record= FALSE;
if (scanning_key_val_iter)
{
if (kv_it.get_next())
{
kv_it.close();
scanning_key_val_iter= FALSE;
}
else
have_record= TRUE;
}
else
{
while (kv_it.init(this))
{
if (key_buffer->is_empty())
{
if (auto_refill)
{
int res;
if ((res= refill_buffer()))
return res;
if (key_buffer->is_empty())
{
index_scan_eof= TRUE;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
}
else
{
/* Buffer refills are managed by somebody else for us */
index_scan_eof= TRUE;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
}
}
scanning_key_val_iter= TRUE;
}
if (have_record &&
(!mrr_funcs.skip_index_tuple ||
!mrr_funcs.skip_index_tuple(mrr_iter, *(char**)cur_range_info))
&&
(!mrr_funcs.skip_record ||
!mrr_funcs.skip_record(mrr_iter, *(char**)cur_range_info, NULL)))
{
break;
}
/* Go get another (record, range_id) combination */
} /* while */
memcpy(range_info_arg, cur_range_info, sizeof(void*));
DBUG_RETURN(0);
}
/**
DS-MRR/CPK: Fill the buffer with (lookup_tuple, range_id) pairs and sort
Enumerate the input range (=key) sequence, fill the key buffer with
(lookup_key, range_id) pairs and sort it.
When this function returns, either
- key buffer is non-empty, or
- key buffer is empty and source range sequence is exhausted
@note
dsmrr_eof is set to indicate whether we've exhausted the list of ranges
we're scanning.
*/
int Mrr_ordered_index_reader::refill_buffer()
{
int res;
KEY_MULTI_RANGE cur_range;
uchar **range_info_ptr= (uchar**)&cur_range.ptr;
uchar *key_ptr;
DBUG_ENTER("Mrr_ordered_index_reader::refill_buffer");
DBUG_ASSERT(!know_key_tuple_params || key_buffer->is_empty());
if (know_key_tuple_params)
{
buf_manager->reset_buffer_sizes();
key_buffer->reset();
key_buffer->setup_writing(&key_ptr, keypar.key_size_in_keybuf,
is_mrr_assoc? (uchar**)&range_info_ptr : NULL,
sizeof(uchar*));
}
#if 0
if (know_key_tuple_params)
{
if (do_rndpos_scan && rowid_buffer.is_empty())
{
/*
We're using two buffers and both of them are empty now. Restore the
original sizes
*/
rowid_buffer.set_buffer_space(full_buf, rowid_buffer_end);
key_buffer= &backward_key_buf;
key_buffer->set_buffer_space(rowid_buffer_end, full_buf_end);
}
}
is all of the ifdef-ed stuff is handled above?
#endif
while ((!know_key_tuple_params || key_buffer->can_write()) &&
!(res= mrr_funcs.next(mrr_iter, &cur_range)))
{
DBUG_ASSERT(cur_range.range_flag & EQ_RANGE);
if (!know_key_tuple_params)
{
/* This only happens when we've just started filling the buffer */
key_range *sample_key= &cur_range.start_key;
know_key_tuple_params= TRUE;
keypar.key_tuple_length= sample_key->length;
keypar.key_tuple_map= sample_key->keypart_map;
keypar.key_size_in_keybuf= keypar.use_key_pointers ? sizeof(char*) : keypar.key_tuple_length;
KEY *key_info= &h->get_table()->key_info[h->active_index];
keypar.index_ranges_unique= test(key_info->flags & HA_NOSAME &&
key_info->key_parts ==
my_count_bits(sample_key->keypart_map));
buf_manager->setup_buffer_sizes(keypar.key_size_in_keybuf, keypar.key_tuple_map);
key_buffer= buf_manager->get_key_buffer();
key_buffer->setup_writing(&key_ptr, keypar.key_size_in_keybuf,
is_mrr_assoc? (uchar**)&range_info_ptr : NULL,
sizeof(uchar*));
DBUG_ASSERT(key_buffer->can_write());
}
/* Put key, or {key, range_id} pair into the buffer */
if (keypar.use_key_pointers)
key_ptr=(uchar*) &cur_range.start_key.key;
else
key_ptr=(uchar*) cur_range.start_key.key;
key_buffer->write();
}
no_more_keys= test(res);
key_buffer->sort((key_buffer->type() == Lifo_buffer::FORWARD)?
(qsort2_cmp)Mrr_ordered_index_reader::key_tuple_cmp_reverse :
(qsort2_cmp)Mrr_ordered_index_reader::key_tuple_cmp,
(void*)this);
scanning_key_val_iter= FALSE;
index_scan_eof= FALSE;
DBUG_RETURN(0);
}
int Mrr_ordered_index_reader::init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges,
uint mode, Buffer_manager *buf_manager_arg)
{
h= h_arg;
mrr_iter= seq_funcs->init(seq_init_param, n_ranges, mode);
keypar.use_key_pointers= test(mode & HA_MRR_MATERIALIZED_KEYS);
is_mrr_assoc= !test(mode & HA_MRR_NO_ASSOCIATION);
mrr_funcs= *seq_funcs;
know_key_tuple_params= FALSE;
buf_manager= buf_manager_arg;
return 0;
}
static int rowid_cmp_reverse(void *h, uchar *a, uchar *b)
{
return - ((handler*)h)->cmp_ref(a, b);
}
int Mrr_ordered_rndpos_reader::init(handler *h_arg,
Mrr_index_reader *index_reader_arg,
uint mode,
Lifo_buffer *buf)
{
h= h_arg;
index_reader= index_reader_arg;
rowid_buffer= buf;
is_mrr_assoc= !test(mode & HA_MRR_NO_ASSOCIATION);
//rowid_buff_elem_size= h->ref_length;
//if (!(mode & HA_MRR_NO_ASSOCIATION))
// rowid_buff_elem_size += sizeof(char*);
return index_reader->refill_buffer();
}
/**
DS-MRR: Fill and sort the rowid buffer
Scan the MRR ranges and collect ROWIDs (or {ROWID, range_id} pairs) into
buffer. When the buffer is full or scan is completed, sort the buffer by
rowid and return.
When this function returns, either rowid buffer is not empty, or the source
of lookup keys (i.e. ranges) is exhaused.
dsmrr_eof is set to indicate whether we've exhausted the list of ranges we're
scanning. This function never returns HA_ERR_END_OF_FILE.
@retval 0 OK, the next portion of rowids is in the buffer,
properly ordered
@retval other Error
*/
int Mrr_ordered_rndpos_reader::refill_buffer()
{
char *range_info;
uchar **range_info_ptr= (uchar**)&range_info;
int res;
DBUG_ENTER("Mrr_ordered_rndpos_reader::refill_buffer");
DBUG_ASSERT(rowid_buffer->is_empty());
index_rowid= index_reader->get_rowid_ptr();
rowid_buffer->reset();
rowid_buffer->setup_writing(&index_rowid, h->ref_length,
is_mrr_assoc? (uchar**)&range_info_ptr: NULL,
sizeof(void*));
last_identical_rowid= NULL;
while (rowid_buffer->can_write())
{
res= index_reader->get_next(&range_info);
if (res)
break;
/* Put rowid, or {rowid, range_id} pair into the buffer */
index_reader->h->position(index_reader->h->get_table()->record[0]);
rowid_buffer->write();
}
if (res && res != HA_ERR_END_OF_FILE)
DBUG_RETURN(res);
/* Sort the buffer contents by rowid */
rowid_buffer->sort((qsort2_cmp)rowid_cmp_reverse, (void*)h);
rowid_buffer->setup_reading(&rowid, h->ref_length,
is_mrr_assoc? (uchar**)&rowids_range_id: NULL,
sizeof(void*));
DBUG_RETURN(0);
}
/**
DS-MRR implementation: multi_range_read_next() function.
Calling convention is like multi_range_read_next() has.
*/
int Mrr_ordered_rndpos_reader::get_next(char **range_info)
{
int res;
while (last_identical_rowid)
{
/*
Current record (the one we've returned in previous call) was obtained
from a rowid that matched multiple range_ids. Return this record again,
with next matching range_id.
*/
bool UNINIT_VAR(bres);
bres= rowid_buffer->read();
DBUG_ASSERT(!bres);
if (is_mrr_assoc)
memcpy(range_info, rowids_range_id, sizeof(uchar*));
if (rowid == last_identical_rowid)
{
last_identical_rowid= NULL; /* reached the last of identical rowids */
}
if (!index_reader->skip_record((char*)*range_info, rowid))
{
return 0;
}
}
while (1)
{
if (rowid_buffer->is_empty())
{
/*
We're out of rowids. If there are still some sorted keys, use up them
first (that is, don't call re-fill for keys when we still have some).
*/
if (!index_reader->eof())
{
if ((res= refill_buffer()))
return res; /* for fatal errors */
}
else
{
//TODO: here: redistribute the buffer space, then refill the index
//reader, then refill us.
}
}
last_identical_rowid= NULL;
/* Return eof if there are no rowids in the buffer after re-fill attempt */
if (rowid_buffer->read())
return HA_ERR_END_OF_FILE;
if (is_mrr_assoc)
{
memcpy(range_info, rowids_range_id, sizeof(uchar*));
}
if (index_reader->skip_record(*range_info, rowid))
continue;
res= h->ha_rnd_pos(h->get_table()->record[0], rowid);
if (res == HA_ERR_RECORD_DELETED)
continue;
/*
Check if subsequent buffer elements have the same rowid value as this
one. If yes, remember this fact so that we don't make any more rnd_pos()
calls with this value.
*/
if (!res)
{
uchar *cur_rowid= rowid;
/*
Note: this implies that SQL layer doesn't touch table->record[0]
between calls.
*/
Lifo_buffer_iterator it;
it.init(rowid_buffer);
while (!it.read()) // reads to (rowid, ...)
{
if (h->cmp_ref(rowid, cur_rowid))
break;
last_identical_rowid= rowid;
}
}
return 0;
}
return res;
}
/************ MRR_impl classes end *********************************************/
/**************************************************************************** /****************************************************************************
* DS-MRR implementation * DS-MRR implementation
***************************************************************************/ ***************************************************************************/
...@@ -310,9 +719,8 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs, ...@@ -310,9 +719,8 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges, uint mode, void *seq_init_param, uint n_ranges, uint mode,
HANDLER_BUFFER *buf) HANDLER_BUFFER *buf)
{ {
Item *pushed_cond= NULL;
handler *new_h2= 0;
THD *thd= current_thd; THD *thd= current_thd;
int res;
DBUG_ENTER("DsMrr_impl::dsmrr_init"); DBUG_ENTER("DsMrr_impl::dsmrr_init");
/* /*
...@@ -320,88 +728,130 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs, ...@@ -320,88 +728,130 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
has not been called, so set the owner handler here as well. has not been called, so set the owner handler here as well.
*/ */
h= h_arg; h= h_arg;
if (mode & HA_MRR_USE_DEFAULT_IMPL || mode & HA_MRR_SORTED) is_mrr_assoc= !test(mode & HA_MRR_NO_ASSOCIATION);
if ((mode & HA_MRR_USE_DEFAULT_IMPL) || (mode & HA_MRR_SORTED))
{ {
use_default_impl= TRUE; DBUG_ASSERT(h->inited == handler::INDEX);
const int retval= Mrr_simple_index_reader *s= &strategy_factory.simple_index_reader;
h->handler::multi_range_read_init(seq_funcs, seq_init_param, n_ranges, res= s->init(h, seq_funcs, seq_init_param, n_ranges, mode, this);
mode, buf); strategy= s;
DBUG_RETURN(retval); DBUG_RETURN(res);
} }
use_default_impl= FALSE;
is_mrr_assoc= !test(mode & HA_MRR_NO_ASSOCIATION);
/* Neither of strategies used below can handle sorting */
DBUG_ASSERT(!(mode & HA_MRR_SORTED));
/* /*
Determine whether we'll need to do key sorting and/or rnd_pos() scan Determine whether we'll need to do key sorting and/or rnd_pos() scan
*/ */
do_sort_keys= FALSE; index_strategy= NULL;
if ((mode & HA_MRR_SINGLE_POINT) && Mrr_ordered_index_reader *ordered_idx_reader= NULL;
optimizer_flag(thd, OPTIMIZER_SWITCH_MRR_SORT_KEYS)) if ((mode & HA_MRR_SINGLE_POINT) &&
optimizer_flag(thd, OPTIMIZER_SWITCH_MRR_SORT_KEYS))
{ {
do_sort_keys= TRUE; index_strategy= ordered_idx_reader= &strategy_factory.ordered_index_reader;
use_key_pointers= test(mode & HA_MRR_MATERIALIZED_KEYS);
} }
else
index_strategy= &strategy_factory.simple_index_reader;
do_rndpos_scan= FALSE; strategy= index_strategy;
bool doing_cpk_scan= check_cpk_scan(thd, h->inited == handler::INDEX? /*
h->active_index: h2->active_index, mode); We don't need a rowid-to-rndpos step if
if (!doing_cpk_scan /* && !index_only_read */) - We're doing a scan on clustered primary key
- [In the future] We're doing an index_only read
*/
DBUG_ASSERT(h->inited == handler::INDEX ||
(h->inited == handler::RND && h2 &&
h2->inited == handler::INDEX));
handler *h_idx= (h->inited == handler::INDEX)? h: h2;
keyno= h_idx->active_index;
Mrr_ordered_rndpos_reader *disk_strategy= NULL;
if (!(keyno == table->s->primary_key && h_idx->primary_key_is_clustered()))
{ {
/* Will use rowid buffer to store/sort rowids, etc */ strategy= disk_strategy= &strategy_factory.ordered_rndpos_reader;
do_rndpos_scan= TRUE;
} }
/*
We should either sort keys, or do ordered rnd_pos scan, or both. If we
decide to do neither, we should have used default MRR implementation.
*/
DBUG_ASSERT(do_sort_keys || do_rndpos_scan);
if (is_mrr_assoc) if (is_mrr_assoc)
status_var_increment(table->in_use->status_var.ha_multi_range_read_init_count); status_var_increment(thd->status_var.ha_multi_range_read_init_count);
/*
At start, alloc all of the buffer for rowids. When/if key sorting code
figures how much buffer space it needs, it will call setup_buffer_sizes()
to re-distribute the buffer space.
*/
full_buf= buf->buffer; full_buf= buf->buffer;
full_buf_end= buf->buffer_end; full_buf_end= buf->buffer_end;
rowid_buffer.set_buffer_space(full_buf, full_buf_end);
if (do_sort_keys) if (strategy == index_strategy)
{ {
know_key_tuple_params= FALSE; if (ordered_idx_reader)
h->mrr_iter= seq_funcs->init(seq_init_param, n_ranges, mode); ordered_idx_reader->auto_refill= TRUE;
h->mrr_funcs= *seq_funcs; /* Index strategy serves it all. We don't need two handlers, etc */
keyno= (h->inited == handler::INDEX)? h->active_index : h2->active_index; /* Give the buffer to index strategy */
dsmrr_fill_key_buffer(); if ((res= index_strategy->init(h, seq_funcs, seq_init_param, n_ranges,
mode, this)))
if (dsmrr_eof && !do_rndpos_scan) goto error;
buf->end_of_used_area= key_buffer->end_of_space();
} }
else
if (!do_rndpos_scan)
{ {
/* /*
We have the keys and won't need to fetch rowids, as key lookup will be If we got here the request is served by both index and rndpos strategies
the last operation, done in multi_range_read_next(). working together.
*/ */
DBUG_RETURN(0); rowid_buffer.set_buffer_space(buf->buffer, buf->buffer_end);
if ((res= setup_two_handlers()))
DBUG_RETURN(res);
if (ordered_idx_reader)
ordered_idx_reader->auto_refill= FALSE;
if ((res= index_strategy->init(h2, seq_funcs, seq_init_param, n_ranges,
mode, this)) ||
(res= disk_strategy->init(h, index_strategy, mode, &rowid_buffer)))
{
goto error;
}
} }
rowid_buff_elem_size= h->ref_length + (is_mrr_assoc? sizeof(char*) : 0); if (strategy->refill_buffer())
goto error;
/* /*
There can be two cases: If we have scanned through all intervals in *seq, then adjust *buf to
- This is the first call since index_init(), h2==NULL indicate that the remaining buffer space will not be used.
Need to setup h2 then.
- This is not the first call, h2 is initalized and set up appropriately.
The caller might have called h->index_init(), need to switch h to
rnd_pos calls.
*/ */
// if (dsmrr_eof)
// buf->end_of_used_area= rowid_buffer.end_of_space();
DBUG_RETURN(0);
error:
close_second_handler();
strategy= NULL;
DBUG_RETURN(1);
}
/*
Whatever the current state is, make it so that we have two handler objects:
- h (the primary) - initialized for rnd_pos() scan
- h2 (the secondary) - initialized for scanning the index specified in
this->keyno
RETURN
0 OK
HA_XXX Error code
*/
int DsMrr_impl::setup_two_handlers()
{
int res;
THD *thd= current_thd;
DBUG_ENTER("DsMrr_impl::setup_two_handlers");
if (!h2) if (!h2)
{ {
handler *new_h2;
Item *pushed_cond= NULL;
DBUG_ASSERT(h->inited == handler::INDEX);
/* Create a separate handler object to do rnd_pos() calls. */ /* Create a separate handler object to do rnd_pos() calls. */
/* /*
::clone() takes up a lot of stack, especially on 64 bit platforms. ::clone() takes up a lot of stack, especially on 64 bit platforms.
...@@ -409,8 +859,6 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs, ...@@ -409,8 +859,6 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
*/ */
if (check_stack_overrun(thd, 5*STACK_MIN_SIZE, (uchar*) &new_h2)) if (check_stack_overrun(thd, 5*STACK_MIN_SIZE, (uchar*) &new_h2))
DBUG_RETURN(1); DBUG_RETURN(1);
DBUG_ASSERT(h->active_index != MAX_KEY);
keyno= h->active_index;
/* Create a separate handler object to do rnd_pos() calls. */ /* Create a separate handler object to do rnd_pos() calls. */
if (!(new_h2= h->clone(thd->mem_root)) || if (!(new_h2= h->clone(thd->mem_root)) ||
...@@ -422,25 +870,27 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs, ...@@ -422,25 +870,27 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
if (keyno == h->pushed_idx_cond_keyno) if (keyno == h->pushed_idx_cond_keyno)
pushed_cond= h->pushed_idx_cond; pushed_cond= h->pushed_idx_cond;
Mrr_strategy *save_strategy= strategy;
strategy= NULL;
/* /*
Caution: this call will invoke this->dsmrr_close(). Do not put the Caution: this call will invoke this->dsmrr_close(). Do not put the
created secondary table handler into this->h2 or it will delete it. created secondary table handler new_h2 into this->h2 or it will delete
it. Also, save the picked strategy
*/ */
if (h->ha_index_end()) res= h->ha_index_end();
{
h2=new_h2;
goto error;
}
use_default_impl= FALSE; strategy= save_strategy;
h2= new_h2; /* Ok, now can put it into h2 */ h2= new_h2; /* Ok, now can put it into h2 */
if (res || (res= (h->ha_rnd_init(FALSE))))
goto error;
table->prepare_for_position(); table->prepare_for_position();
h2->extra(HA_EXTRA_KEYREAD); h2->extra(HA_EXTRA_KEYREAD);
h2->mrr_funcs= *seq_funcs; //psergey3-todo: sort out where to store
h2->mrr_iter= h->mrr_iter; h2->mrr_iter= h->mrr_iter;
if (h2->ha_index_init(keyno, FALSE)) if ((res= h2->ha_index_init(keyno, FALSE)))
goto error; goto error;
if (pushed_cond) if (pushed_cond)
...@@ -448,152 +898,56 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs, ...@@ -448,152 +898,56 @@ int DsMrr_impl::dsmrr_init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
} }
else else
{ {
DBUG_ASSERT(h2 && h2->inited==handler::INDEX);
/* /*
We get here when the access alternates betwen MRR scan(s) and non-MRR We get here when the access alternates betwen MRR scan(s) and non-MRR
scans. scans.
Calling h->index_end() will invoke dsmrr_close() for this object,
which will delete h2. We need to keep it, so save put it away and dont
let it be deleted:
*/
handler *save_h2= h2;
h2= NULL;
int res= (h->inited == handler::INDEX && h->ha_index_end());
h2= save_h2;
use_default_impl= FALSE;
if (res)
goto error;
}
if (!do_sort_keys &&
h2->handler::multi_range_read_init(seq_funcs, seq_init_param, n_ranges,
mode, buf))
{
goto error;
}
if (dsmrr_fill_rowid_buffer())
{
goto error;
}
/*
If the above call has scanned through all intervals in *seq, then
adjust *buf to indicate that the remaining buffer space will not be used.
*/
// if (dsmrr_eof)
// buf->end_of_used_area= rowid_buffer.end_of_space();
/*
h->inited == INDEX may occur when 'range checked for each record' is
used.
*/
if ((h->inited != handler::RND) &&
((h->inited==handler::INDEX? h->ha_index_end(): FALSE) ||
(h->ha_rnd_init(FALSE))))
goto error;
h->mrr_funcs= *seq_funcs;
DBUG_RETURN(0);
error:
h2->ha_index_or_rnd_end();
h2->ha_external_lock(current_thd, F_UNLCK);
h2->close();
delete h2;
h2= NULL;
DBUG_RETURN(1);
}
void DsMrr_impl::dsmrr_close()
{
DBUG_ENTER("DsMrr_impl::dsmrr_close");
if (h2)
{
h2->ha_index_or_rnd_end();
h2->ha_external_lock(current_thd, F_UNLCK);
h2->close();
delete h2;
h2= NULL;
}
use_default_impl= TRUE;
DBUG_VOID_RETURN;
}
static int rowid_cmp_reverse(void *h, uchar *a, uchar *b)
{
return - ((handler*)h)->cmp_ref(a, b);
}
/**
DS-MRR: Fill and sort the rowid buffer
Scan the MRR ranges and collect ROWIDs (or {ROWID, range_id} pairs) into
buffer. When the buffer is full or scan is completed, sort the buffer by
rowid and return.
When this function returns, either rowid buffer is not empty, or the source
of lookup keys (i.e. ranges) is exhaused.
dsmrr_eof is set to indicate whether we've exhausted the list of ranges we're
scanning. This function never returns HA_ERR_END_OF_FILE.
@retval 0 OK, the next portion of rowids is in the buffer,
properly ordered
@retval other Error
*/
int DsMrr_impl::dsmrr_fill_rowid_buffer()
{
char *range_info;
uchar **range_info_ptr= (uchar**)&range_info;
int res;
DBUG_ENTER("DsMrr_impl::dsmrr_fill_rowid_buffer");
DBUG_ASSERT(rowid_buffer.is_empty());
rowid_buffer.reset();
rowid_buffer.setup_writing(&h2->ref, h2->ref_length,
is_mrr_assoc? (uchar**)&range_info_ptr: NULL,
sizeof(void*));
last_identical_rowid= NULL;
while (rowid_buffer.can_write())
{
if (do_sort_keys)
res= dsmrr_next_from_index(&range_info);
else
res= h2->handler::multi_range_read_next(&range_info);
if (res)
break;
KEY_MULTI_RANGE *curr_range= &h2->handler::mrr_cur_range;
if (!do_sort_keys && /* If keys are sorted then this check is already done */
h2->mrr_funcs.skip_index_tuple &&
h2->mrr_funcs.skip_index_tuple(h2->mrr_iter, curr_range->ptr))
continue;
/* Put rowid, or {rowid, range_id} pair into the buffer */
h2->position(table->record[0]);
rowid_buffer.write(); Calling h->index_end() will invoke dsmrr_close() for this object,
which will delete h2. We need to keep it, so put it away and dont
let it be deleted:
*/
if (h->inited == handler::INDEX)
{
handler *save_h2= h2;
Mrr_strategy *save_strategy= strategy;
h2= NULL;
strategy= NULL;
res= h->ha_index_end();
h2= save_h2;
strategy= save_strategy;
if (res)
goto error;
}
if ((h->inited == handler::RND) && h->ha_rnd_init(FALSE))
goto error;
} }
DBUG_RETURN(0);
error:
//close_second_handler(); -- caller does that
DBUG_RETURN(res);
}
if (res && res != HA_ERR_END_OF_FILE)
DBUG_RETURN(res);
if (!do_sort_keys) void DsMrr_impl::close_second_handler()
dsmrr_eof= test(res == HA_ERR_END_OF_FILE); {
if (h2)
{
h2->ha_index_or_rnd_end();
h2->ha_external_lock(current_thd, F_UNLCK);
h2->close();
delete h2;
h2= NULL;
}
}
/* Sort the buffer contents by rowid */
rowid_buffer.sort((qsort2_cmp)rowid_cmp_reverse, (void*)h);
rowid_buffer.setup_reading(&rowid, h->ref_length, void DsMrr_impl::dsmrr_close()
is_mrr_assoc? (uchar**)&rowids_range_id: NULL, sizeof(void*)); {
DBUG_RETURN(0); DBUG_ENTER("DsMrr_impl::dsmrr_close");
close_second_handler();
strategy= NULL;
DBUG_VOID_RETURN;
} }
...@@ -601,21 +955,21 @@ int DsMrr_impl::dsmrr_fill_rowid_buffer() ...@@ -601,21 +955,21 @@ int DsMrr_impl::dsmrr_fill_rowid_buffer()
my_qsort2-compatible function to compare key tuples my_qsort2-compatible function to compare key tuples
*/ */
int DsMrr_impl::key_tuple_cmp(void* arg, uchar* key1, uchar* key2) int Mrr_ordered_index_reader::key_tuple_cmp(void* arg, uchar* key1, uchar* key2)
{ {
DsMrr_impl *dsmrr= (DsMrr_impl*)arg; Mrr_ordered_index_reader *this_= (Mrr_ordered_index_reader*)arg;
TABLE *table= dsmrr->h->table; TABLE *table= this_->h->get_table();
int res; int res;
KEY_PART_INFO *part= table->key_info[dsmrr->keyno].key_part; KEY_PART_INFO *part= table->key_info[this_->h->active_index].key_part;
if (dsmrr->use_key_pointers) if (this_->keypar.use_key_pointers)
{ {
/* the buffer stores pointers to keys, get to the keys */ /* the buffer stores pointers to keys, get to the keys */
key1= *((uchar**)key1); key1= *((uchar**)key1);
key2= *((uchar**)key2); // todo is this alignment-safe? key2= *((uchar**)key2); // todo is this alignment-safe?
} }
uchar *key1_end= key1 + dsmrr->key_tuple_length; uchar *key1_end= key1 + this_->keypar.key_tuple_length;
while (key1 < key1_end) while (key1 < key1_end)
{ {
...@@ -648,7 +1002,7 @@ equals: ...@@ -648,7 +1002,7 @@ equals:
} }
int DsMrr_impl::key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2) int Mrr_ordered_index_reader::key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2)
{ {
return -key_tuple_cmp(arg, key1, key2); return -key_tuple_cmp(arg, key1, key2);
} }
...@@ -664,24 +1018,17 @@ int DsMrr_impl::key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2) ...@@ -664,24 +1018,17 @@ int DsMrr_impl::key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2)
This function must be called when all buffers are empty This function must be called when all buffers are empty
*/ */
void DsMrr_impl::setup_buffer_sizes(key_range *sample_key) void DsMrr_impl::setup_buffer_sizes(uint key_size_in_keybuf,
key_part_map key_tuple_map)
{ {
key_tuple_length= sample_key->length; uint key_buff_elem_size= key_size_in_keybuf +
key_tuple_map= sample_key->keypart_map; (int)is_mrr_assoc * sizeof(void*);
key_size_in_keybuf= use_key_pointers ? sizeof(char*) :
key_tuple_length;
key_buff_elem_size= key_size_in_keybuf +
(int)is_mrr_assoc * sizeof(void*);
KEY *key_info= &h->table->key_info[keyno]; KEY *key_info= &h->get_table()->key_info[keyno];
index_ranges_unique= test(key_info->flags & HA_NOSAME && if (strategy == index_strategy)
key_info->key_parts ==
my_count_bits(sample_key->keypart_map));
if (!do_rndpos_scan)
{ {
/* Give all space to forward key buffer. */ /* Give all space to the key buffer, key buffer must be forward */
key_buffer= &forward_key_buf; key_buffer= &forward_key_buf;
//identical_key_it= &forward_key_it;
key_buffer->set_buffer_space(full_buf, full_buf_end); key_buffer->set_buffer_space(full_buf, full_buf_end);
/* Just in case, tell rowid buffer that it has zero size: */ /* Just in case, tell rowid buffer that it has zero size: */
...@@ -730,100 +1077,21 @@ void DsMrr_impl::setup_buffer_sizes(key_range *sample_key) ...@@ -730,100 +1077,21 @@ void DsMrr_impl::setup_buffer_sizes(key_range *sample_key)
rowid_buffer_end= full_buf + bytes_for_rowids; rowid_buffer_end= full_buf + bytes_for_rowids;
rowid_buffer.set_buffer_space(full_buf, rowid_buffer_end); rowid_buffer.set_buffer_space(full_buf, rowid_buffer_end);
key_buffer= &backward_key_buf; key_buffer= &backward_key_buf;
//identical_key_it= &backward_key_it;
key_buffer->set_buffer_space(rowid_buffer_end, full_buf_end); key_buffer->set_buffer_space(rowid_buffer_end, full_buf_end);
} }
/** void DsMrr_impl::reset_buffer_sizes()
DS-MRR/CPK: Fill the buffer with (lookup_tuple, range_id) pairs and sort
Enumerate the input range (=key) sequence, fill the key buffer with
(lookup_key, range_id) pairs and sort it.
When this function returns, either
- key buffer is non-empty, or
- key buffer is empty and source range sequence is exhausted
@note
dsmrr_eof is set to indicate whether we've exhausted the list of ranges
we're scanning.
*/
void DsMrr_impl::dsmrr_fill_key_buffer()
{ {
int res; rowid_buffer.set_buffer_space(full_buf, rowid_buffer_end);
KEY_MULTI_RANGE cur_range; key_buffer= &backward_key_buf;
uchar **range_info_ptr= (uchar**)&cur_range.ptr; key_buffer->set_buffer_space(rowid_buffer_end, full_buf_end);
DBUG_ENTER("DsMrr_impl::dsmrr_fill_key_buffer");
DBUG_ASSERT(!know_key_tuple_params || key_buffer->is_empty());
uchar *key_ptr;
if (know_key_tuple_params)
{
if (do_rndpos_scan && rowid_buffer.is_empty())
{
/*
We're using two buffers and both of them are empty now. Restore the
original sizes
*/
rowid_buffer.set_buffer_space(full_buf, rowid_buffer_end);
key_buffer= &backward_key_buf;
key_buffer->set_buffer_space(rowid_buffer_end, full_buf_end);
}
key_buffer->reset();
key_buffer->setup_writing(&key_ptr, key_size_in_keybuf,
is_mrr_assoc? (uchar**)&range_info_ptr : NULL,
sizeof(uchar*));
}
while ((!know_key_tuple_params || key_buffer->can_write()) &&
!(res= h->mrr_funcs.next(h->mrr_iter, &cur_range)))
{
DBUG_ASSERT(cur_range.range_flag & EQ_RANGE);
if (!know_key_tuple_params)
{
/* This only happens when we've just started filling the buffer */
setup_buffer_sizes(&cur_range.start_key);
know_key_tuple_params= TRUE;
key_buffer->setup_writing(&key_ptr, key_size_in_keybuf,
is_mrr_assoc? (uchar**)&range_info_ptr : NULL,
sizeof(uchar*));
DBUG_ASSERT(key_buffer->can_write());
}
/* Put key, or {key, range_id} pair into the buffer */
if (use_key_pointers)
key_ptr=(uchar*) &cur_range.start_key.key;
else
key_ptr=(uchar*) cur_range.start_key.key;
key_buffer->write();
}
dsmrr_eof= test(res);
key_buffer->sort((key_buffer->type() == Lifo_buffer::FORWARD)?
(qsort2_cmp)DsMrr_impl::key_tuple_cmp_reverse :
(qsort2_cmp)DsMrr_impl::key_tuple_cmp,
(void*)this);
key_buffer->setup_reading(&cur_index_tuple, key_size_in_keybuf,
is_mrr_assoc? (uchar**)&cur_range_info: NULL,
sizeof(void*));
scanning_key_val_iter= FALSE;
index_scan_eof= FALSE;
DBUG_VOID_RETURN;
} }
/** /**
Take unused space from the key buffer and give it to the rowid buffer Take unused space from the key buffer and give it to the rowid buffer
*/ */
//psergey-todo: do invoke this function.
void DsMrr_impl::reallocate_buffer_space() void DsMrr_impl::reallocate_buffer_space()
{ {
uchar *unused_start, *unused_end; uchar *unused_start, *unused_end;
...@@ -834,37 +1102,43 @@ void DsMrr_impl::reallocate_buffer_space() ...@@ -834,37 +1102,43 @@ void DsMrr_impl::reallocate_buffer_space()
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////
bool Key_value_records_iterator::init(DsMrr_impl *dsmrr_arg)
bool Key_value_records_iterator::init(Mrr_ordered_index_reader *owner_arg)
{ {
int res; int res;
dsmrr= dsmrr_arg; //h= h_arg;
handler *file= dsmrr->do_rndpos_scan? dsmrr->h2 : dsmrr->h; //param= param_arg;
owner= owner_arg;
identical_key_it.init(dsmrr->key_buffer); identical_key_it.init(owner->key_buffer);
/* Get the first pair into (cur_index_tuple, cur_range_info) */ /* Get the first pair into (cur_index_tuple, cur_range_info) */
owner->key_buffer->setup_reading(&cur_index_tuple, owner->keypar.key_size_in_keybuf,
owner->is_mrr_assoc? (uchar**)&owner->cur_range_info: NULL,
sizeof(void*));
if (identical_key_it.read()) if (identical_key_it.read())
return TRUE; return TRUE;
uchar *key_in_buf= dsmrr->cur_index_tuple; uchar *key_in_buf= cur_index_tuple;
last_identical_key_ptr= dsmrr->cur_index_tuple; last_identical_key_ptr= cur_index_tuple;
if (dsmrr->use_key_pointers) if (owner->keypar.use_key_pointers)
dsmrr->cur_index_tuple= *((uchar**)dsmrr->cur_index_tuple); cur_index_tuple= *((uchar**)cur_index_tuple);
/* Check out how many more identical keys are following */ /* Check out how many more identical keys are following */
uchar *save_cur_index_tuple= dsmrr->cur_index_tuple; uchar *save_cur_index_tuple= cur_index_tuple;
while (!identical_key_it.read()) while (!identical_key_it.read())
{ {
if (DsMrr_impl::key_tuple_cmp(dsmrr, key_in_buf, dsmrr->cur_index_tuple)) if (Mrr_ordered_index_reader::key_tuple_cmp(owner, key_in_buf, cur_index_tuple))
break; break;
last_identical_key_ptr= dsmrr->cur_index_tuple; last_identical_key_ptr= cur_index_tuple;
} }
identical_key_it.init(dsmrr->key_buffer); identical_key_it.init(owner->key_buffer);
dsmrr->cur_index_tuple= save_cur_index_tuple; cur_index_tuple= save_cur_index_tuple;
res= file->ha_index_read_map(dsmrr->table->record[0], res= owner->h->ha_index_read_map(owner->h->get_table()->record[0],
dsmrr->cur_index_tuple, cur_index_tuple,
dsmrr->key_tuple_map, owner->keypar.key_tuple_map,
HA_READ_KEY_EXACT); HA_READ_KEY_EXACT);
if (res) if (res)
{ {
...@@ -878,27 +1152,27 @@ bool Key_value_records_iterator::init(DsMrr_impl *dsmrr_arg) ...@@ -878,27 +1152,27 @@ bool Key_value_records_iterator::init(DsMrr_impl *dsmrr_arg)
int Key_value_records_iterator::get_next() int Key_value_records_iterator::get_next()
{ {
handler *file= dsmrr->do_rndpos_scan? dsmrr->h2 : dsmrr->h;
int res; int res;
if (get_next_row) if (get_next_row)
{ {
if (dsmrr->index_ranges_unique) if (owner->keypar.index_ranges_unique)
return HA_ERR_END_OF_FILE; /* Max one match */ return HA_ERR_END_OF_FILE; /* Max one match */
if ((res= file->ha_index_next_same(dsmrr->table->record[0], handler *h= owner->h;
dsmrr->cur_index_tuple, if ((res= h->ha_index_next_same(h->get_table()->record[0],
dsmrr->key_tuple_length))) cur_index_tuple,
owner->keypar.key_tuple_length)))
{ {
/* EOF is EOF for iterator, also, any error means EOF on the iterator */ /* EOF is EOF for iterator, also, any error means EOF on the iterator */
return res; return res;
} }
identical_key_it.init(dsmrr->key_buffer); identical_key_it.init(owner->key_buffer);
get_next_row= FALSE; get_next_row= FALSE;
} }
identical_key_it.read(); // This gets us next range_id. identical_key_it.read(); // This gets us next range_id.
if (!last_identical_key_ptr || (dsmrr->cur_index_tuple == last_identical_key_ptr)) if (!last_identical_key_ptr || (cur_index_tuple == last_identical_key_ptr))
{ {
get_next_row= TRUE; get_next_row= TRUE;
} }
...@@ -907,92 +1181,8 @@ int Key_value_records_iterator::get_next() ...@@ -907,92 +1181,8 @@ int Key_value_records_iterator::get_next()
void Key_value_records_iterator::close() void Key_value_records_iterator::close()
{ {
while (!dsmrr->key_buffer->read() && while (!owner->key_buffer->read() &&
(dsmrr->cur_index_tuple != last_identical_key_ptr)) {} (cur_index_tuple != last_identical_key_ptr)) {}
}
/**
DS-MRR/CPK: multi_range_read_next() function
@param range_info OUT identifier of range that the returned record belongs to
@note
This function walks over key buffer and does index reads, i.e. it produces
{current_record, range_id} pairs.
The function has the same call contract like multi_range_read_next()'s.
We actually iterate over nested sequences:
- a disjoint sequence of index ranges
- each range has multiple records
- each record goes into multiple identical ranges.
@retval 0 OK, next record was successfully read
@retval HA_ERR_END_OF_FILE End of records
@retval Other Some other error
*/
int DsMrr_impl::dsmrr_next_from_index(char **range_info_arg)
{
DBUG_ENTER("DsMrr_impl::dsmrr_next_from_index");
while (1)
{
bool have_record= FALSE;
if (scanning_key_val_iter)
{
if (kv_it.get_next())
{
kv_it.close();
scanning_key_val_iter= FALSE;
}
else
have_record= TRUE;
}
else
{
while (kv_it.init(this))
{
if (key_buffer->is_empty())
{
if (dsmrr_eof)
{
index_scan_eof= TRUE;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
/*
When rowid fetching is used, it controls all buffer refills. When we're
on our own, try refilling our buffer.
*/
if (!do_rndpos_scan)
dsmrr_fill_key_buffer();
if (key_buffer->is_empty())
{
index_scan_eof= TRUE;
DBUG_RETURN(HA_ERR_END_OF_FILE);
}
}
}
scanning_key_val_iter= TRUE;
}
if (have_record &&
(!h->mrr_funcs.skip_index_tuple ||
!h->mrr_funcs.skip_index_tuple(h->mrr_iter, *(char**)cur_range_info))
&&
(!h->mrr_funcs.skip_record ||
!h->mrr_funcs.skip_record(h->mrr_iter, *(char**)cur_range_info, NULL)))
{
break;
}
/* Go get another (record, range_id) combination */
} /* while */
memcpy(range_info_arg, cur_range_info, sizeof(void*));
DBUG_RETURN(0);
} }
...@@ -1004,119 +1194,7 @@ int DsMrr_impl::dsmrr_next_from_index(char **range_info_arg) ...@@ -1004,119 +1194,7 @@ int DsMrr_impl::dsmrr_next_from_index(char **range_info_arg)
int DsMrr_impl::dsmrr_next(char **range_info) int DsMrr_impl::dsmrr_next(char **range_info)
{ {
int res; return strategy->get_next(range_info);
if (use_default_impl)
return h->handler::multi_range_read_next(range_info);
if (!do_rndpos_scan)
return dsmrr_next_from_index(range_info);
while (last_identical_rowid)
{
/*
Current record (the one we've returned in previous call) was obtained
from a rowid that matched multiple range_ids. Return this record again,
with next matching range_id.
*/
bool bres= rowid_buffer.read();
DBUG_ASSERT(!bres);
if (is_mrr_assoc)
memcpy(range_info, rowids_range_id, sizeof(uchar*));
if (rowid == last_identical_rowid)
{
last_identical_rowid= NULL; /* reached the last of identical rowids */
}
if (!h2->mrr_funcs.skip_record ||
!h2->mrr_funcs.skip_record(h2->mrr_iter, (char *) *range_info, rowid))
{
return 0;
}
}
while (1)
{
if (rowid_buffer.is_empty())
{
if (do_sort_keys)
{
if (!index_scan_eof)
{
/* There are some sorted keys left. Use them to get rowids */
if ((res= dsmrr_fill_rowid_buffer()))
return res; /* for fatal errors */
}
while (rowid_buffer.is_empty())
{
if (dsmrr_eof)
return HA_ERR_END_OF_FILE;
dsmrr_fill_key_buffer();
if ((res= dsmrr_fill_rowid_buffer()))
return res;
}
}
else
{
/*
There is no buffer with sorted keys. If fill_rowid_buffer() haven't
reached eof condition before, try refilling the buffer.
*/
if (dsmrr_eof)
return HA_ERR_END_OF_FILE;
if ((res= dsmrr_fill_rowid_buffer()))
return res;
}
}
last_identical_rowid= NULL;
/* Return eof if there are no rowids in the buffer after re-fill attempt */
if (rowid_buffer.read())
return HA_ERR_END_OF_FILE;
if (is_mrr_assoc)
{
memcpy(range_info, rowids_range_id, sizeof(uchar*));
}
if (h2->mrr_funcs.skip_record &&
h2->mrr_funcs.skip_record(h2->mrr_iter, *range_info, rowid))
continue;
res= h->ha_rnd_pos(table->record[0], rowid);
if (res == HA_ERR_RECORD_DELETED)
continue;
/*
Check if subsequent buffer elements have the same rowid value as this
one. If yes, remember this fact so that we don't make any more rnd_pos()
calls with this value.
*/
if (!res)
{
uchar *cur_rowid= rowid;
/*
Note: this implies that SQL layer doesn't touch table->record[0]
between calls.
*/
Lifo_buffer_iterator it;
it.init(&rowid_buffer);
while (!it.read()) // reads to (rowid, ...)
{
if (h2->cmp_ref(rowid, cur_rowid))
break;
last_identical_rowid= rowid;
}
}
return 0;
}
return res;
} }
...@@ -1239,11 +1317,11 @@ bool key_uses_partial_cols(TABLE *table, uint keyno) ...@@ -1239,11 +1317,11 @@ bool key_uses_partial_cols(TABLE *table, uint keyno)
bool DsMrr_impl::check_cpk_scan(THD *thd, uint keyno, uint mrr_flags) bool DsMrr_impl::check_cpk_scan(THD *thd, uint keyno, uint mrr_flags)
{ {
return test((mrr_flags & HA_MRR_SINGLE_POINT) && return test((mrr_flags & HA_MRR_SINGLE_POINT) && // check
!(mrr_flags & HA_MRR_SORTED) && // !(mrr_flags & HA_MRR_SORTED) &&
keyno == table->s->primary_key && keyno == table->s->primary_key &&
h->primary_key_is_clustered() && h->primary_key_is_clustered() &&
optimizer_flag(thd, OPTIMIZER_SWITCH_MRR_SORT_KEYS)); optimizer_flag(thd, OPTIMIZER_SWITCH_MRR_SORT_KEYS)); //check
} }
......
...@@ -50,6 +50,26 @@ ...@@ -50,6 +50,26 @@
class DsMrr_impl; class DsMrr_impl;
class Key_parameters
{
public:
/* TRUE <=> We can get at most one index tuple for a lookup key */
bool index_ranges_unique;
uint key_tuple_length; /* Length of index lookup tuple, in bytes */
key_part_map key_tuple_map; /* keyparts used in index lookup tuples */
/*
This is
= key_tuple_length if we copy keys to buffer
= sizeof(void*) if we're using pointers to materialized keys.
*/
uint key_size_in_keybuf;
/* TRUE <=> don't copy key values, use pointers to them instead. */
bool use_key_pointers;
};
/** /**
Iterator over (record, range_id) pairs that match given key value. Iterator over (record, range_id) pairs that match given key value.
...@@ -57,16 +77,23 @@ class DsMrr_impl; ...@@ -57,16 +77,23 @@ class DsMrr_impl;
key value. A key value may have multiple matching records, so we'll need to key value. A key value may have multiple matching records, so we'll need to
produce a cross-product of sets of matching records and range_id-s. produce a cross-product of sets of matching records and range_id-s.
*/ */
class Mrr_ordered_index_reader;
class Key_value_records_iterator class Key_value_records_iterator
{ {
/* Scan parameters */ /* Scan parameters */
DsMrr_impl *dsmrr; Key_parameters *param;
Lifo_buffer_iterator identical_key_it; Lifo_buffer_iterator identical_key_it;
uchar *last_identical_key_ptr; uchar *last_identical_key_ptr;
bool get_next_row; bool get_next_row;
//handler *h;
/* TRUE <=> We can get at most one index tuple for a lookup key */
//bool index_ranges_unique;
Mrr_ordered_index_reader *owner;
/* key_buffer.read() reads to here */
uchar *cur_index_tuple;
public: public:
bool init(DsMrr_impl *dsmrr); bool init(Mrr_ordered_index_reader *owner_arg);
/* /*
Get next (key_val, range_id) pair. Get next (key_val, range_id) pair.
...@@ -74,9 +101,184 @@ public: ...@@ -74,9 +101,184 @@ public:
int get_next(); int get_next();
void close(); void close();
friend class Mrr_ordered_index_reader;
}; };
/*
Something that will manage buffers for those that call it
*/
class Buffer_manager
{
public:
virtual void reset_buffer_sizes()= 0;
virtual void setup_buffer_sizes(uint key_size_in_keybuf,
key_part_map key_tuple_map)=0;
virtual Lifo_buffer* get_key_buffer()= 0;
virtual ~Buffer_manager(){}
};
/*
Abstract MRR execution strategy
An object of this class produces (R, range_info) pairs where R can be an
index tuple or a table record.
Getting HA_ERR_END_OF_FILE from get_next() means that the source should be
re-filled. if eof() returns true after refill attempt, then end of stream has
been reached and get_next() must not be called anymore.
*/
class Mrr_strategy
{
public:
virtual int get_next(char **range_info) = 0;
virtual int refill_buffer()=0;
virtual ~Mrr_strategy() {};
};
/* A common base for strategies that do index scans and produce index tuples */
class Mrr_index_reader : public Mrr_strategy
{
public:
handler *h;
virtual int init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges,
uint mode, Buffer_manager *buf_manager_arg) = 0;
virtual bool eof() = 0;
virtual uchar *get_rowid_ptr()= 0;
virtual bool skip_record(char *range_id, uchar *rowid)=0;
};
/*
A "bypass" strategy that uses default MRR implementation (i.e.
handler::multi_range_read_XXX() calls) to produce rows.
*/
class Mrr_simple_index_reader : public Mrr_index_reader
{
int res;
public:
int init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges,
uint mode, Buffer_manager *buf_manager_arg);
int get_next(char **range_info);
int refill_buffer() { return 0; }
bool eof() { return test(res); }
uchar *get_rowid_ptr() { return h->ref; }
bool skip_record(char *range_id, uchar *rowid)
{
return (h->mrr_funcs.skip_record &&
h->mrr_funcs.skip_record(h->mrr_iter, range_id, rowid));
}
};
/*
A strategy that sorts index lookup keys before scanning the index
*/
class Mrr_ordered_index_reader : public Mrr_index_reader
{
public:
int init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
void *seq_init_param, uint n_ranges,
uint mode, Buffer_manager *buf_manager_arg);
int get_next(char **range_info);
int refill_buffer();
bool eof() { return index_scan_eof; }
uchar *get_rowid_ptr() { return h->ref; }
bool skip_record(char *range_info, uchar *rowid)
{
return (mrr_funcs.skip_record &&
mrr_funcs.skip_record(mrr_iter, range_info, rowid));
}
private:
Key_value_records_iterator kv_it;
bool scanning_key_val_iter;
char *cur_range_info;
/* Buffer to store (key, range_id) pairs */
Lifo_buffer *key_buffer;
Buffer_manager *buf_manager;
/* Initially FALSE, becomes TRUE when we've set key_tuple_xxx members */
bool know_key_tuple_params;
// bool use_key_pointers;
Key_parameters keypar;
/* TRUE <=> need range association, buffers hold {rowid, range_id} pairs */
bool is_mrr_assoc;
bool no_more_keys;
RANGE_SEQ_IF mrr_funcs;
range_seq_t mrr_iter;
bool auto_refill;
bool index_scan_eof;
static int key_tuple_cmp(void* arg, uchar* key1, uchar* key2);
static int key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2);
//void cleanup();
friend class Key_value_records_iterator;
friend class DsMrr_impl;
friend class Mrr_ordered_rndpos_reader;
};
/* MRR strategy that fetches rowids */
class Mrr_ordered_rndpos_reader : public Mrr_strategy
{
public:
int init(handler *h, Mrr_index_reader *index_reader, uint mode,
Lifo_buffer *buf);
int get_next(char **range_info);
int refill_buffer();
void cleanup();
private:
handler *h;
DsMrr_impl *dsmrr;
/* This what we get (rowid, range_info) pairs from */
Mrr_index_reader *index_reader;
uchar *index_rowid;
/* TRUE <=> need range association, buffers hold {rowid, range_id} pairs */
bool is_mrr_assoc;
uchar *last_identical_rowid;
Lifo_buffer *rowid_buffer;
/* = h->ref_length [ + sizeof(range_assoc_info) ] */
//uint rowid_buff_elem_size;
/* rowid_buffer.read() will set the following: */
uchar *rowid;
uchar *rowids_range_id;
};
class Mrr_strategy_factory
{
public:
Mrr_ordered_rndpos_reader ordered_rndpos_reader;
Mrr_ordered_index_reader ordered_index_reader;
Mrr_simple_index_reader simple_index_reader;
};
/* /*
DS-MRR implementation for one table. Create/use one object of this class for DS-MRR implementation for one table. Create/use one object of this class for
each ha_{myisam/innobase/etc} object. That object will be further referred to each ha_{myisam/innobase/etc} object. That object will be further referred to
...@@ -154,9 +356,58 @@ public: ...@@ -154,9 +356,58 @@ public:
get record by rowid and return the {record, range_id} pair get record by rowid and return the {record, range_id} pair
4. Repeat the above steps until we've exhausted the list of ranges we're 4. Repeat the above steps until we've exhausted the list of ranges we're
scanning. scanning.
Buffer space management considerations
--------------------------------------
With regards to buffer/memory management, MRR interface specifies that
- SQL layer provides multi_range_read_init() with buffer of certain size.
- MRR implementation may use (i.e. have at its disposal till the end of
the MRR scan) all of the buffer, or return the unused end of the buffer
to SQL layer.
DS-MRR needs buffer in order to accumulate and sort rowids and/or keys. When
we need to accumulate/sort only keys (or only rowids), it is fairly trivial.
When we need to accumulate/sort both keys and rowids, efficient buffer use
gets complicated. We need to:
- First, accumulate keys and sort them
- Then use the keys (smaller values go first) to obtain rowids. A key is not
needed after we've got matching rowids for it.
- Make sure that rowids are accumulated at the front of the buffer, so that we
can return the end part of the buffer to SQL layer, should there be too
few rowid values to occupy the buffer.
All of these goals are achieved by using the following scheme:
| | We get an empty buffer from SQL layer.
| *-|
| *----| First, we fill the buffer with keys. Key_buffer
| *-------| part grows from end of the buffer space to start
| *----------| (In this picture, the buffer is big enough to
| *-------------| accomodate all keys and even have some space left)
| *=============| We want to do key-ordered index scan, so we sort
the keys
|-x *===========| Then we use the keys get rowids. Rowids are
|----x *========| stored from start of buffer space towards the end.
|--------x *=====| The part of the buffer occupied with keys
|------------x *===| gradually frees up space for rowids. In this
|--------------x *=| picture we run out of keys before we've ran out
|----------------x | of buffer space (it can be other way as well).
|================x | Then we sort the rowids.
| |~~~| The unused part of the buffer is at the end, so
we can return it to the SQL layer.
|================* Sorted rowids are then used to read table records
in disk order
*/ */
class DsMrr_impl class DsMrr_impl : public Buffer_manager
{ {
public: public:
typedef void (handler::*range_check_toggle_func_t)(bool on); typedef void (handler::*range_check_toggle_func_t)(bool on);
...@@ -181,6 +432,9 @@ public: ...@@ -181,6 +432,9 @@ public:
void *seq_init_param, uint n_ranges, uint *bufsz, void *seq_init_param, uint n_ranges, uint *bufsz,
uint *flags, COST_VECT *cost); uint *flags, COST_VECT *cost);
private: private:
/* Buffer to store (key, range_id) pairs */
Lifo_buffer *key_buffer;
/* /*
The "owner" handler object (the one that is expected to "own" this object The "owner" handler object (the one that is expected to "own" this object
and call its functions). and call its functions).
...@@ -197,20 +451,16 @@ private: ...@@ -197,20 +451,16 @@ private:
/** Properties of current MRR scan **/ /** Properties of current MRR scan **/
uint keyno; /* index we're running the scan on */ uint keyno; /* index we're running the scan on */
bool use_default_impl; /* TRUE <=> shortcut all calls to default MRR impl */
/* TRUE <=> need range association, buffers hold {rowid, range_id} pairs */ /* TRUE <=> need range association, buffers hold {rowid, range_id} pairs */
bool is_mrr_assoc; bool is_mrr_assoc;
/* TRUE <=> sort the keys before making index lookups */ /* TRUE <=> sort the keys before making index lookups */
bool do_sort_keys; //bool do_sort_keys;
/* TRUE <=> sort rowids and use rnd_pos() to get and return full records */ /* TRUE <=> sort rowids and use rnd_pos() to get and return full records */
bool do_rndpos_scan; //bool do_rndpos_scan;
/*
(if do_sort_keys==TRUE) don't copy key values, use pointers to them
instead.
*/
bool use_key_pointers;
Mrr_strategy_factory strategy_factory;
Mrr_strategy *strategy;
Mrr_index_reader *index_strategy;
/* The whole buffer space that we're using */ /* The whole buffer space that we're using */
uchar *full_buf; uchar *full_buf;
...@@ -226,12 +476,6 @@ private: ...@@ -226,12 +476,6 @@ private:
/** Index scaning and key buffer-related members **/ /** Index scaning and key buffer-related members **/
/* TRUE <=> We can get at most one index tuple for a lookup key */
bool index_ranges_unique;
/* TRUE<=> we're in a middle of enumerating records for a key range */
//bool in_index_range;
/* /*
One of the following two is used for key buffer: forward is used when One of the following two is used for key buffer: forward is used when
we only need key buffer, backward is used when we need both key and rowid we only need key buffer, backward is used when we need both key and rowid
...@@ -240,39 +484,10 @@ private: ...@@ -240,39 +484,10 @@ private:
Forward_lifo_buffer forward_key_buf; Forward_lifo_buffer forward_key_buf;
Backward_lifo_buffer backward_key_buf; Backward_lifo_buffer backward_key_buf;
/* Buffer to store (key, range_id) pairs */ Forward_lifo_buffer rowid_buffer;
Lifo_buffer *key_buffer;
/* Index scan state */
bool scanning_key_val_iter;
/*
TRUE <=> we've got index tuples/rowids for all keys (need this flag because
we may have a situation where we've read everything from the key buffer but
haven't finished with getting index tuples for the last key)
*/
bool index_scan_eof;
Key_value_records_iterator kv_it;
/* key_buffer.read() reads to here */
uchar *cur_index_tuple;
/* if in_index_range==TRUE: range_id of the range we're enumerating */
char *cur_range_info;
/* Initially FALSE, becomes TRUE when we've set key_tuple_xxx members */
bool know_key_tuple_params;
uint key_tuple_length; /* Length of index lookup tuple, in bytes */
key_part_map key_tuple_map; /* keyparts used in index lookup tuples */
/*
This is
= key_tuple_length if we copy keys to buffer
= sizeof(void*) if we're using pointers to materialized keys.
*/
uint key_size_in_keybuf;
/* = key_size_in_keybuf [ + sizeof(range_assoc_info) ] */ /* = key_size_in_keybuf [ + sizeof(range_assoc_info) ] */
uint key_buff_elem_size; //uint key_buff_elem_size_;
/** rnd_pos() scan and rowid buffer-related members **/ /** rnd_pos() scan and rowid buffer-related members **/
...@@ -280,36 +495,27 @@ private: ...@@ -280,36 +495,27 @@ private:
Buffer to store (rowid, range_id) pairs, or just rowids if Buffer to store (rowid, range_id) pairs, or just rowids if
is_mrr_assoc==FALSE is_mrr_assoc==FALSE
*/ */
Forward_lifo_buffer rowid_buffer; //Forward_lifo_buffer rowid_buffer;
/* rowid_buffer.read() will set the following: */
uchar *rowid;
uchar *rowids_range_id;
uchar *last_identical_rowid;
bool dsmrr_eof; /* TRUE <=> We have reached EOF when reading index tuples */
/* = h->ref_length [ + sizeof(range_assoc_info) ] */
uint rowid_buff_elem_size;
bool choose_mrr_impl(uint keyno, ha_rows rows, uint *flags, uint *bufsz, bool choose_mrr_impl(uint keyno, ha_rows rows, uint *flags, uint *bufsz,
COST_VECT *cost); COST_VECT *cost);
bool get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags, bool get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags,
uint *buffer_size, COST_VECT *cost); uint *buffer_size, COST_VECT *cost);
bool check_cpk_scan(THD *thd, uint keyno, uint mrr_flags); bool check_cpk_scan(THD *thd, uint keyno, uint mrr_flags);
static int key_tuple_cmp(void* arg, uchar* key1, uchar* key2);
static int key_tuple_cmp_reverse(void* arg, uchar* key1, uchar* key2);
int dsmrr_fill_rowid_buffer();
void dsmrr_fill_key_buffer();
int dsmrr_next_from_index(char **range_info);
void setup_buffer_sizes(key_range *sample_key);
void reallocate_buffer_space(); void reallocate_buffer_space();
static range_seq_t key_buf_seq_init(void *init_param, uint n_ranges, uint flags); /* Buffer_manager implementation */
static uint key_buf_seq_next(range_seq_t rseq, KEY_MULTI_RANGE *range); void setup_buffer_sizes(uint key_size_in_keybuf, key_part_map key_tuple_map);
void reset_buffer_sizes();
Lifo_buffer* get_key_buffer() { return key_buffer; }
friend class Key_value_records_iterator; friend class Key_value_records_iterator;
friend class Mrr_ordered_index_reader;
friend class Mrr_ordered_rndpos_reader;
int setup_two_handlers();
void close_second_handler();
}; };
/** /**
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment