Skip to content

M
MariaDB
Commit acc83798 authored by Vicențiu Ciorbaru's avatar Vicențiu Ciorbaru
Browse files
Options

Revert "Fixed compilation failure on MacOSX" 

This reverts commit df32495c.
parent 275f7d7d
Hide whitespace changes
Inline Side-by-side
Showing with 313 additions and 350 deletions
include/myisam.h
View file @ acc83798
...@@ -331,8 +331,7 @@ typedef struct st_sort_info ...@@ -331,8 +331,7 @@ typedef struct st_sort_info
my_off_t filelength, dupp, buff_length; my_off_t filelength, dupp, buff_length;
ha_rows max_records; ha_rows max_records;
uint current_key, total_keys; uint current_key, total_keys;
volatile uint got_error; uint got_error, threads_running;
uint threads_running;
myf myf_rw; myf myf_rw;
enum data_file_type new_data_file_type; enum data_file_type new_data_file_type;
} MI_SORT_INFO; } MI_SORT_INFO;
......
storage/maria/ma_sort.c
View file @ acc83798
...@@ -364,211 +364,192 @@ static ha_rows find_all_keys(MARIA_SORT_PARAM *info, ha_rows keys, ...@@ -364,211 +364,192 @@ static ha_rows find_all_keys(MARIA_SORT_PARAM *info, ha_rows keys,
} /* find_all_keys */ } /* find_all_keys */
static my_bool _ma_thr_find_all_keys_exec(MARIA_SORT_PARAM* sort_param) /* Search after all keys and place them in a temp. file */
{
DBUG_ENTER("_ma_thr_find_all_keys");
DBUG_PRINT("enter", ("master: %d", sort_param->master));
my_bool error= FALSE;
if (sort_param->sort_info->got_error)
error= TRUE;
if (error)
DBUG_RETURN(error);
set_sort_param_read_write(sort_param);
ulonglong memavl, old_memavl, sortbuff_size; pthread_handler_t _ma_thr_find_all_keys(void *arg)
{
MARIA_SORT_PARAM *sort_param= (MARIA_SORT_PARAM*) arg;
int error;
size_t memavl, old_memavl;
longlong sortbuff_size;
ha_keys UNINIT_VAR(keys), idx; ha_keys UNINIT_VAR(keys), idx;
uint sort_length; uint sort_length;
uint maxbuffer; uint maxbuffer;
uchar **sort_keys= NULL; uchar **sort_keys=0;
error=1;
if (my_thread_init())
goto err;
my_b_clear(&sort_param->tempfile); { /* Add extra block since DBUG_ENTER declare variables */
my_b_clear(&sort_param->tempfile_for_exceptions); DBUG_ENTER("_ma_thr_find_all_keys");
bzero((char*) &sort_param->buffpek, sizeof(sort_param->buffpek)); DBUG_PRINT("enter", ("master: %d", sort_param->master));
bzero((char*) &sort_param->unique, sizeof(sort_param->unique)); if (sort_param->sort_info->got_error)
goto err;
set_sort_param_read_write(sort_param);
sortbuff_size= sort_param->sortbuff_size; my_b_clear(&sort_param->tempfile);
memavl= MY_MAX(sortbuff_size, MIN_SORT_BUFFER); my_b_clear(&sort_param->tempfile_for_exceptions);
idx= (ha_keys) sort_param->sort_info->max_records; bzero((char*) &sort_param->buffpek,sizeof(sort_param->buffpek));
sort_length= sort_param->key_length; bzero((char*) &sort_param->unique, sizeof(sort_param->unique));
maxbuffer= 1;
while (memavl >= MIN_SORT_BUFFER) sortbuff_size= sort_param->sortbuff_size;
{ memavl= MY_MAX(sortbuff_size, MIN_SORT_MEMORY);
if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <= idx= (ha_keys) sort_param->sort_info->max_records;
(my_off_t) memavl) sort_length= sort_param->key_length;
keys= idx+1; maxbuffer= 1;
else if ((sort_param->sort_info->param->testflag &
(T_FORCE_SORT_MEMORY | T_CREATE_MISSING_KEYS)) == while (memavl >= MIN_SORT_MEMORY)
T_FORCE_SORT_MEMORY)
{
/*
Use all of the given sort buffer for key data.
Allocate 1000 buffers at a start for new data. More buffers
will be allocated when needed.
*/
keys= memavl / (sort_length+sizeof(char*));
maxbuffer= (uint) MY_MIN((ulonglong) 1000, (idx / keys)+1);
}
else
{ {
uint maxbuffer_org; if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <= (my_off_t) memavl)
do keys= idx+1;
else if ((sort_param->sort_info->param->testflag &
(T_FORCE_SORT_MEMORY | T_CREATE_MISSING_KEYS)) ==
T_FORCE_SORT_MEMORY)
{ {
maxbuffer_org= maxbuffer; /*
if (memavl < sizeof(BUFFPEK)*maxbuffer || Use all of the given sort buffer for key data.
(keys=(memavl-sizeof(BUFFPEK)*maxbuffer)/ Allocate 1000 buffers at a start for new data. More buffers
(sort_length+sizeof(char*))) <= 1 || will be allocated when needed.
keys < (uint) maxbuffer) */
keys= memavl / (sort_length+sizeof(char*));
maxbuffer= (uint) MY_MIN((ulonglong) 1000, (idx / keys)+1);
}
else
{
uint maxbuffer_org;
do
{ {
mysql_mutex_lock(&sort_param->sort_info->mutex); maxbuffer_org= maxbuffer;
_ma_check_print_error(sort_param->sort_info->param, if (memavl < sizeof(BUFFPEK)*maxbuffer ||
"aria_sort_buffer_size is too small. Current " (keys=(memavl-sizeof(BUFFPEK)*maxbuffer)/
"aria_sort_buffer_size: %llu rows: %llu " (sort_length+sizeof(char*))) <= 1 ||
"sort_length: %u", keys < maxbuffer)
sortbuff_size, (ulonglong) idx, sort_length); {
mysql_mutex_unlock(&sort_param->sort_info->mutex); _ma_check_print_error(sort_param->sort_info->param,
DBUG_RETURN(TRUE); "aria_sort_buffer_size is too small. Current aria_sort_buffer_size: %llu rows: %llu sort_length: %u",
sortbuff_size, (ulonglong) idx, sort_length);
goto err;
}
} }
while ((maxbuffer= (uint) (idx/(keys-1)+1)) != maxbuffer_org);
} }
while ((maxbuffer= (uint) (idx/(keys-1)+1)) != maxbuffer_org); if ((sort_keys= (uchar **)
} my_malloc(keys*(sort_length+sizeof(char*))+
if ((sort_keys= (uchar **) ((sort_param->keyinfo->flag & HA_FULLTEXT) ?
my_malloc(keys*(sort_length+sizeof(char*))+ HA_FT_MAXBYTELEN : 0), MYF(0))))
((sort_param->keyinfo->flag & HA_FULLTEXT) ?
HA_FT_MAXBYTELEN : 0), MYF(0))))
{
if (my_init_dynamic_array(&sort_param->buffpek, sizeof(BUFFPEK),
maxbuffer, MY_MIN(maxbuffer/2, 1000), MYF(0)))
{ {
my_free(sort_keys); if (my_init_dynamic_array(&sort_param->buffpek, sizeof(BUFFPEK),
sort_keys= NULL; /* Safety against double free on error. */ maxbuffer, MY_MIN(maxbuffer/2, 1000), MYF(0)))
{
my_free(sort_keys);
sort_keys= (uchar **) NULL; /* for err: label */
}
else
break;
} }
else old_memavl= memavl;
break; if ((memavl= memavl/4*3) < MIN_SORT_MEMORY &&
old_memavl > MIN_SORT_MEMORY)
memavl= MIN_SORT_MEMORY;
} }
old_memavl= memavl; if (memavl < MIN_SORT_MEMORY)
if ((memavl= memavl/4*3) < MIN_SORT_MEMORY && {
old_memavl > MIN_SORT_MEMORY) /* purecov: begin inspected */
memavl= MIN_SORT_MEMORY; _ma_check_print_error(sort_param->sort_info->param,
} "aria_sort_buffer_size is too small. Current aria_sort_buffer_size: %llu rows: %llu sort_length: %u",
if (memavl < MIN_SORT_MEMORY) sortbuff_size, (ulonglong) idx, sort_length);
{ my_errno= ENOMEM;
/* purecov: begin inspected */ goto err;
mysql_mutex_lock(&sort_param->sort_info->mutex);
_ma_check_print_error(sort_param->sort_info->param,
"aria_sort_buffer_size is too small. Current "
"aria_sort_buffer_size: %llu rows: %llu "
"sort_length: %u",
sortbuff_size, (ulonglong) idx, sort_length);
my_errno= ENOMEM;
mysql_mutex_unlock(&sort_param->sort_info->mutex);
DBUG_RETURN(TRUE);
/* purecov: end inspected */ /* purecov: end inspected */
} }
if (sort_param->sort_info->param->testflag & T_VERBOSE)
my_fprintf(stdout,
"Key %d - Allocating buffer for %llu keys\n",
sort_param->key + 1, (ulonglong) keys);
sort_param->sort_keys= sort_keys;
idx= error= 0; if (sort_param->sort_info->param->testflag & T_VERBOSE)
sort_keys[0]= (uchar*) (sort_keys+keys); my_fprintf(stdout,
"Key %d - Allocating buffer for %llu keys\n",
sort_param->key + 1, (ulonglong) keys);
sort_param->sort_keys= sort_keys;
DBUG_PRINT("info", ("reading keys")); idx= error= 0;
while (!(error= sort_param->sort_info->got_error) && sort_keys[0]= (uchar*) (sort_keys+keys);
!(error= (*sort_param->key_read)(sort_param, sort_keys[idx])))
{ DBUG_PRINT("info", ("reading keys"));
if (sort_param->real_key_length > sort_param->key_length) while (!(error= sort_param->sort_info->got_error) &&
!(error= (*sort_param->key_read)(sort_param, sort_keys[idx])))
{ {
if (write_key(sort_param, sort_keys[idx], if (sort_param->real_key_length > sort_param->key_length)
&sort_param->tempfile_for_exceptions)) {
goto err; if (write_key(sort_param, sort_keys[idx],
continue; &sort_param->tempfile_for_exceptions))
} goto err;
continue;
}
if (++idx == keys) if (++idx == keys)
{
if (sort_param->write_keys(sort_param, sort_keys, idx - 1,
(BUFFPEK *)alloc_dynamic(&sort_param->
buffpek),
&sort_param->tempfile))
goto err;
sort_keys[0]= (uchar*) (sort_keys+keys);
memcpy(sort_keys[0], sort_keys[idx - 1],
(size_t) sort_param->key_length);
idx= 1;
}
sort_keys[idx]= sort_keys[idx - 1] + sort_param->key_length;
}
if (error > 0)
goto err;
if (sort_param->buffpek.elements)
{ {
if (sort_param->write_keys(sort_param, sort_keys, idx - 1, if (sort_param->write_keys(sort_param,sort_keys, idx,
(BUFFPEK *)alloc_dynamic(&sort_param->buffpek), (BUFFPEK *) alloc_dynamic(&sort_param->
buffpek),
&sort_param->tempfile)) &sort_param->tempfile))
goto err; goto err;
sort_keys[0]= (uchar*) (sort_keys+keys); sort_param->keys= (sort_param->buffpek.elements - 1) * (keys - 1) + idx;
memcpy(sort_keys[0], sort_keys[idx - 1], (size_t) sort_param->key_length);
idx= 1;
} }
sort_keys[idx]= sort_keys[idx - 1] + sort_param->key_length; else
} sort_param->keys= idx;
if (error > 0)
goto err;
if (sort_param->buffpek.elements)
{
if (sort_param->write_keys(sort_param,sort_keys, idx,
(BUFFPEK *) alloc_dynamic(&sort_param->
buffpek),
&sort_param->tempfile))
goto err;
sort_param->keys= (sort_param->buffpek.elements - 1) * (keys - 1) + idx;
}
else
sort_param->keys= idx;
DBUG_RETURN(FALSE); goto ok;
err: err:
DBUG_PRINT("error", ("got some error")); DBUG_PRINT("error", ("got some error"));
my_free(sort_keys); sort_param->sort_info->got_error= 1; /* no need to protect with a mutex */
sort_param->sort_keys= 0; my_free(sort_keys);
delete_dynamic(& sort_param->buffpek); sort_param->sort_keys= 0;
close_cached_file(&sort_param->tempfile); delete_dynamic(& sort_param->buffpek);
close_cached_file(&sort_param->tempfile_for_exceptions); close_cached_file(&sort_param->tempfile);
close_cached_file(&sort_param->tempfile_for_exceptions);
DBUG_RETURN(TRUE);
} ok:
free_root(&sort_param->wordroot, MYF(0));
/* Search after all keys and place them in a temp. file */ /*
Detach from the share if the writer is involved. Avoid others to
pthread_handler_t _ma_thr_find_all_keys(void *arg) be blocked. This includes a flush of the write buffer. This will
{ also indicate EOF to the readers.
MARIA_SORT_PARAM *sort_param= (MARIA_SORT_PARAM*) arg; That means that a writer always gets here first and readers -
my_bool error= FALSE; only when they see EOF. But if a reader finishes prematurely
/* If my_thread_init fails */ because of an error it may reach this earlier - don't allow it
if (my_thread_init()) to detach the writer thread.
error= TRUE; */
if (sort_param->master && sort_param->sort_info->info->rec_cache.share)
if (error || _ma_thr_find_all_keys_exec(sort_param)) remove_io_thread(&sort_param->sort_info->info->rec_cache);
error= TRUE;
/* Readers detach from the share if any. Avoid others to be blocked. */
/* if (sort_param->read_cache.share)
Thread must clean up after itself. remove_io_thread(&sort_param->read_cache);
*/
free_root(&sort_param->wordroot, MYF(0));
/*
Detach from the share if the writer is involved. Avoid others to
be blocked. This includes a flush of the write buffer. This will
also indicate EOF to the readers.
That means that a writer always gets here first and readers -
only when they see EOF. But if a reader finishes prematurely
because of an error it may reach this earlier - don't allow it
to detach the writer thread.
*/
if (sort_param->master && sort_param->sort_info->info->rec_cache.share)
remove_io_thread(&sort_param->sort_info->info->rec_cache);
/* Readers detach from the share if any. Avoid others to be blocked. */
if (sort_param->read_cache.share)
remove_io_thread(&sort_param->read_cache);
mysql_mutex_lock(&sort_param->sort_info->mutex);
if (error)
sort_param->sort_info->got_error= 1;
if (!--sort_param->sort_info->threads_running)
mysql_cond_signal(&sort_param->sort_info->cond);
mysql_mutex_unlock(&sort_param->sort_info->mutex);
mysql_mutex_lock(&sort_param->sort_info->mutex);
if (!--sort_param->sort_info->threads_running)
mysql_cond_signal(&sort_param->sort_info->cond);
mysql_mutex_unlock(&sort_param->sort_info->mutex);
DBUG_PRINT("exit", ("======== ending thread ========"));
}
my_thread_end(); my_thread_end();
return NULL; return NULL;
} }
......
storage/maria/maria_def.h
View file @ acc83798
...@@ -67,8 +67,7 @@ typedef struct st_maria_sort_info ...@@ -67,8 +67,7 @@ typedef struct st_maria_sort_info
pgcache_page_no_t page; pgcache_page_no_t page;
ha_rows max_records; ha_rows max_records;
uint current_key, total_keys; uint current_key, total_keys;
volatile uint got_error; uint got_error, threads_running;
uint threads_running;
myf myf_rw; myf myf_rw;
enum data_file_type new_data_file_type, org_data_file_type; enum data_file_type new_data_file_type, org_data_file_type;
} MARIA_SORT_INFO; } MARIA_SORT_INFO;
......
storage/myisam/sort.c
View file @ acc83798
...@@ -344,208 +344,192 @@ static ha_rows find_all_keys(MI_SORT_PARAM *info, ha_rows keys, ...@@ -344,208 +344,192 @@ static ha_rows find_all_keys(MI_SORT_PARAM *info, ha_rows keys,
DBUG_RETURN((*maxbuffer)*(keys-1)+idx); DBUG_RETURN((*maxbuffer)*(keys-1)+idx);
} /* find_all_keys */ } /* find_all_keys */
static my_bool thr_find_all_keys_exec(MI_SORT_PARAM *sort_param) /* Search after all keys and place them in a temp. file */
{
DBUG_ENTER("thr_find_all_keys");
DBUG_PRINT("enter", ("master: %d", sort_param->master));
my_bool error= FALSE;
if (sort_param->sort_info->got_error)
error= TRUE;
if (error)
DBUG_RETURN(error);
set_sort_param_read_write(sort_param);
pthread_handler_t thr_find_all_keys(void *arg)
{
MI_SORT_PARAM *sort_param= (MI_SORT_PARAM*) arg;
int error;
ulonglong memavl, old_memavl, sortbuff_size; ulonglong memavl, old_memavl, sortbuff_size;
ha_keys UNINIT_VAR(keys), idx; ha_keys UNINIT_VAR(keys), idx;
uint sort_length; uint sort_length;
uint maxbuffer; uint maxbuffer;
uchar **sort_keys= NULL; uchar **sort_keys=0;
my_b_clear(&sort_param->tempfile); error=1;
my_b_clear(&sort_param->tempfile_for_exceptions);
bzero((char*) &sort_param->buffpek, sizeof(sort_param->buffpek));
bzero((char*) &sort_param->unique, sizeof(sort_param->unique));
if (my_thread_init())
goto err;
sortbuff_size= sort_param->sortbuff_size; { /* Add extra block since DBUG_ENTER declare variables */
memavl= MY_MAX(sortbuff_size, MIN_SORT_BUFFER); DBUG_ENTER("thr_find_all_keys");
idx= (ha_keys) sort_param->sort_info->max_records; DBUG_PRINT("enter", ("master: %d", sort_param->master));
sort_length= sort_param->key_length; if (sort_param->sort_info->got_error)
maxbuffer= 1; goto err;
while (memavl >= MIN_SORT_BUFFER) set_sort_param_read_write(sort_param);
{
if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <= my_b_clear(&sort_param->tempfile);
(my_off_t) memavl) my_b_clear(&sort_param->tempfile_for_exceptions);
keys= idx+1; bzero((char*) &sort_param->buffpek, sizeof(sort_param->buffpek));
else if ((sort_param->sort_info->param->testflag & bzero((char*) &sort_param->unique, sizeof(sort_param->unique));
(T_FORCE_SORT_MEMORY | T_CREATE_MISSING_KEYS)) == sort_keys= (uchar **) NULL;
T_FORCE_SORT_MEMORY)
{ sortbuff_size= sort_param->sortbuff_size;
/* memavl= MY_MAX(sortbuff_size, MIN_SORT_BUFFER);
Use all of the given sort buffer for key data. idx= (ha_keys) sort_param->sort_info->max_records;
Allocate 1000 buffers at a start for new data. More buffers sort_length= sort_param->key_length;
will be allocated when needed. maxbuffer= 1;
*/
keys= memavl / (sort_length+sizeof(char*)); while (memavl >= MIN_SORT_BUFFER)
maxbuffer= (uint) MY_MIN((ulonglong) 1000, (idx / keys)+1);
}
else
{ {
uint maxbuffer_org; if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <=
do (my_off_t) memavl)
keys= idx+1;
else if ((sort_param->sort_info->param->testflag &
(T_FORCE_SORT_MEMORY | T_CREATE_MISSING_KEYS)) ==
T_FORCE_SORT_MEMORY)
{ {
maxbuffer_org= maxbuffer; /*
if (memavl < sizeof(BUFFPEK)*maxbuffer || Use all of the given sort buffer for key data.
(keys=(memavl-sizeof(BUFFPEK)*maxbuffer)/ Allocate 1000 buffers at a start for new data. More buffers
(sort_length+sizeof(char*))) <= 1 || will be allocated when needed.
keys < (uint) maxbuffer) */
keys= memavl / (sort_length+sizeof(char*));
maxbuffer= (uint) MY_MIN((ulonglong) 1000, (idx / keys)+1);
}
else
{
uint maxbuffer_org;
do
{ {
mysql_mutex_lock(&sort_param->sort_info->mutex); maxbuffer_org= maxbuffer;
mi_check_print_error(sort_param->sort_info->param, if (memavl < sizeof(BUFFPEK)*maxbuffer ||
"myisam_sort_buffer_size is too small. Current " (keys=(memavl-sizeof(BUFFPEK)*maxbuffer)/
"myisam_sort_buffer_size: %llu rows: %llu sort_length: %u", (sort_length+sizeof(char*))) <= 1 ||
sortbuff_size, (ulonglong) idx, sort_length); keys < (uint) maxbuffer)
mysql_mutex_unlock(&sort_param->sort_info->mutex); {
DBUG_RETURN(TRUE); mi_check_print_error(sort_param->sort_info->param,
"myisam_sort_buffer_size is too small. Current myisam_sort_buffer_size: %llu rows: %llu sort_length: %u",
sortbuff_size, (ulonglong) idx, sort_length);
goto err;
}
} }
while ((maxbuffer= (uint) (idx/(keys-1)+1)) != maxbuffer_org);
} }
while ((maxbuffer= (uint) (idx/(keys-1)+1)) != maxbuffer_org); if ((sort_keys= (uchar**)
} my_malloc(keys*(sort_length+sizeof(char*))+
if ((sort_keys= my_malloc(keys * (sort_length + sizeof(char *)) + ((sort_param->keyinfo->flag & HA_FULLTEXT) ?
((sort_param->keyinfo->flag & HA_FULLTEXT) ? HA_FT_MAXBYTELEN : 0), MYF(0))))
HA_FT_MAXBYTELEN : 0), MYF(0))))
{
if (my_init_dynamic_array(&sort_param->buffpek, sizeof(BUFFPEK),
maxbuffer, MY_MIN(maxbuffer/2, 1000), MYF(0)))
{ {
my_free(sort_keys); if (my_init_dynamic_array(&sort_param->buffpek, sizeof(BUFFPEK),
sort_keys= NULL; /* Safety against double free on error. */ maxbuffer, MY_MIN(maxbuffer/2, 1000), MYF(0)))
{
my_free(sort_keys);
sort_keys= (uchar **) NULL; /* for err: label */
}
else
break;
} }
else old_memavl= memavl;
break; if ((memavl= memavl / 4 * 3) < MIN_SORT_BUFFER &&
old_memavl > MIN_SORT_BUFFER)
memavl= MIN_SORT_BUFFER;
} }
old_memavl= memavl; if (memavl < MIN_SORT_BUFFER)
if ((memavl= memavl / 4 * 3) < MIN_SORT_BUFFER && {
old_memavl > MIN_SORT_BUFFER) /* purecov: begin inspected */
memavl= MIN_SORT_BUFFER; mi_check_print_error(sort_param->sort_info->param,
} "myisam_sort_buffer_size is too small. Current myisam_sort_buffer_size: %llu rows: %llu sort_length: %u",
if (memavl < MIN_SORT_BUFFER) sortbuff_size, (ulonglong) idx, sort_length);
{ my_errno= ENOMEM;
/* purecov: begin inspected */ goto err;
mysql_mutex_lock(&sort_param->sort_info->mutex);
mi_check_print_error(sort_param->sort_info->param,
"myisam_sort_buffer_size is too small. Current "
"myisam_sort_buffer_size: %llu rows: %llu sort_length: %u",
sortbuff_size, (ulonglong) idx, sort_length);
my_errno= ENOMEM;
mysql_mutex_unlock(&sort_param->sort_info->mutex);
DBUG_RETURN(TRUE);
/* purecov: end inspected */ /* purecov: end inspected */
} }
if (sort_param->sort_info->param->testflag & T_VERBOSE) if (sort_param->sort_info->param->testflag & T_VERBOSE)
my_fprintf(stdout, my_fprintf(stdout,
"Key %d - Allocating buffer for %llu keys\n", "Key %d - Allocating buffer for %llu keys\n",
sort_param->key + 1, (ulonglong) keys); sort_param->key + 1, (ulonglong) keys);
sort_param->sort_keys= sort_keys; sort_param->sort_keys= sort_keys;
idx= error= 0; idx= error= 0;
sort_keys[0]= (uchar*) (sort_keys+keys); sort_keys[0]= (uchar*) (sort_keys+keys);
DBUG_PRINT("info", ("reading keys")); DBUG_PRINT("info", ("reading keys"));
while (!(error= sort_param->sort_info->got_error) && while (!(error= sort_param->sort_info->got_error) &&
!(error= (*sort_param->key_read)(sort_param, sort_keys[idx]))) !(error= (*sort_param->key_read)(sort_param, sort_keys[idx])))
{
if (sort_param->real_key_length > sort_param->key_length)
{ {
if (write_key(sort_param, sort_keys[idx], if (sort_param->real_key_length > sort_param->key_length)
&sort_param->tempfile_for_exceptions)) {
goto err; if (write_key(sort_param, sort_keys[idx],
continue; &sort_param->tempfile_for_exceptions))
} goto err;
continue;
}
if (++idx == keys) if (++idx == keys)
{
if (sort_param->write_keys(sort_param, sort_keys, idx - 1,
(BUFFPEK*) alloc_dynamic(&sort_param->buffpek),
&sort_param->tempfile))
goto err;
sort_keys[0]= (uchar*) (sort_keys+keys);
memcpy(sort_keys[0], sort_keys[idx - 1],
(size_t) sort_param->key_length);
idx= 1;
}
sort_keys[idx]= sort_keys[idx - 1] + sort_param->key_length;
}
if (error > 0)
goto err;
if (sort_param->buffpek.elements)
{ {
if (sort_param->write_keys(sort_param, sort_keys, idx - 1, if (sort_param->write_keys(sort_param, sort_keys, idx,
(BUFFPEK*) alloc_dynamic(&sort_param->buffpek), (BUFFPEK*) alloc_dynamic(&sort_param->buffpek),
&sort_param->tempfile)) &sort_param->tempfile))
goto err; goto err;
sort_keys[0]= (uchar*) (sort_keys+keys); sort_param->keys= (sort_param->buffpek.elements - 1) * (keys - 1) + idx;
memcpy(sort_keys[0], sort_keys[idx - 1], (size_t) sort_param->key_length);
idx= 1;
} }
sort_keys[idx]= sort_keys[idx - 1] + sort_param->key_length; else
} sort_param->keys= idx;
if (error > 0)
goto err;
if (sort_param->buffpek.elements)
{
if (sort_param->write_keys(sort_param, sort_keys, idx,
(BUFFPEK*) alloc_dynamic(&sort_param->buffpek),
&sort_param->tempfile))
goto err;
sort_param->keys= (sort_param->buffpek.elements - 1) * (keys - 1) + idx;
}
else
sort_param->keys= idx;
DBUG_RETURN(FALSE); goto ok;
err: err:
DBUG_PRINT("error", ("got some error")); DBUG_PRINT("error", ("got some error"));
sort_param->sort_info->got_error= 1; /* no need to protect with a mutex */ sort_param->sort_info->got_error= 1; /* no need to protect with a mutex */
my_free(sort_keys); my_free(sort_keys);
sort_param->sort_keys= 0; sort_param->sort_keys= 0;
delete_dynamic(& sort_param->buffpek); delete_dynamic(& sort_param->buffpek);
close_cached_file(&sort_param->tempfile); close_cached_file(&sort_param->tempfile);
close_cached_file(&sort_param->tempfile_for_exceptions); close_cached_file(&sort_param->tempfile_for_exceptions);
DBUG_RETURN(TRUE); ok:
} free_root(&sort_param->wordroot, MYF(0));
/*
/* Search after all keys and place them in a temp. file */ Detach from the share if the writer is involved. Avoid others to
be blocked. This includes a flush of the write buffer. This will
also indicate EOF to the readers.
That means that a writer always gets here first and readers -
only when they see EOF. But if a reader finishes prematurely
because of an error it may reach this earlier - don't allow it
to detach the writer thread.
*/
if (sort_param->master && sort_param->sort_info->info->rec_cache.share)
remove_io_thread(&sort_param->sort_info->info->rec_cache);
/* Readers detach from the share if any. Avoid others to be blocked. */
if (sort_param->read_cache.share)
remove_io_thread(&sort_param->read_cache);
pthread_handler_t thr_find_all_keys(void *arg) mysql_mutex_lock(&sort_param->sort_info->mutex);
{ if (!--sort_param->sort_info->threads_running)
MI_SORT_PARAM *sort_param= (MI_SORT_PARAM*) arg; mysql_cond_signal(&sort_param->sort_info->cond);
my_bool error= FALSE; mysql_mutex_unlock(&sort_param->sort_info->mutex);
/* If my_thread_init fails */ DBUG_PRINT("exit", ("======== ending thread ========"));
if (my_thread_init()) DBUG_LEAVE;
error= TRUE; }
if (error || thr_find_all_keys_exec(sort_param))
error= TRUE;
/*
Thread must clean up after itself.
*/
free_root(&sort_param->wordroot, MYF(0));
/*
Detach from the share if the writer is involved. Avoid others to
be blocked. This includes a flush of the write buffer. This will
also indicate EOF to the readers.
That means that a writer always gets here first and readers -
only when they see EOF. But if a reader finishes prematurely
because of an error it may reach this earlier - don't allow it
to detach the writer thread.
*/
if (sort_param->master && sort_param->sort_info->info->rec_cache.share)
remove_io_thread(&sort_param->sort_info->info->rec_cache);
/* Readers detach from the share if any. Avoid others to be blocked. */
if (sort_param->read_cache.share)
remove_io_thread(&sort_param->read_cache);
mysql_mutex_lock(&sort_param->sort_info->mutex);
if (error)
sort_param->sort_info->got_error= 1;
if (!--sort_param->sort_info->threads_running)
mysql_cond_signal(&sort_param->sort_info->cond);
mysql_mutex_unlock(&sort_param->sort_info->mutex);
my_thread_end(); my_thread_end();
return NULL; return NULL;
} }
......
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
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7