1berry/MariaDB-server
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Indentation cleanup & new comments

Browse Source
This commit is contained in:
monty@hundin.mysql.fi 2002-06-28 09:18:23 +03:00
parent ddc8c5403e
commit ade20c5b19
11 changed files with 216 additions and 261 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
libmysql/Makefile.shared
View File

@ -62,9 +62,9 @@ mysysobjects1 = my_init.lo my_static.lo my_malloc.lo my_realloc.lo \
my_getopt.lo my_gethostbyname.lo my_getopt.lo my_gethostbyname.lo
# Not needed in the minimum library # Not needed in the minimum library
mysysobjects2 = getvar.lo my_lib.lo mysysobjects2 = my_lib.lo
mysysobjects = $(mysysobjects1) $(mysysobjects2) mysysobjects = $(mysysobjects1) $(mysysobjects2)
target_libadd = $(mysysobjects) $(mystringsobjects) $(dbugobjects) \ target_libadd = $(mysysobjects) $(mystringsobjects) $(dbugobjects) \
$(vio_objects) $(vio_objects)
target_ldflags = -version-info @SHARED_LIB_VERSION@ target_ldflags = -version-info @SHARED_LIB_VERSION@
vio_objects= vio.lo viosocket.lo viossl.lo viosslfactories.lo vio_objects= vio.lo viosocket.lo viossl.lo viosslfactories.lo

4
myisam/mi_cache.c
View File

@ -72,8 +72,8 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length,
in_buff_length=0; in_buff_length=0;
if (flag & READING_NEXT || info->share) if (flag & READING_NEXT || info->share)
{ {
if (pos != if (pos != (info->pos_in_file + (uint) (info->read_end -
(info->pos_in_file + (uint) (info->read_end - info->request_pos))) info->request_pos)))
{ {
info->pos_in_file=pos; /* Force start here */ info->pos_in_file=pos; /* Force start here */
info->read_pos=info->read_end=info->request_pos; /* Everything used */ info->read_pos=info->read_end=info->request_pos; /* Everything used */

146
myisam/mi_check.c
View File

@ -1203,10 +1203,11 @@ int mi_repair(MI_CHECK *param, register MI_INFO *info,
for (i=0 ; i < share->state.header.max_block_size ; i++) for (i=0 ; i < share->state.header.max_block_size ; i++)
share->state.key_del[i]= HA_OFFSET_ERROR; share->state.key_del[i]= HA_OFFSET_ERROR;
/* I think mi_repair and mi_repair_by_sort should do the same /*
(according, e.g. to ha_myisam::repair), but as mi_repair doesn't I think mi_repair and mi_repair_by_sort should do the same
touch key_map it cannot be used to T_CREATE_MISSING_KEYS. (according, e.g. to ha_myisam::repair), but as mi_repair doesn't
That is what the next line is for... (serg) touch key_map it cannot be used to T_CREATE_MISSING_KEYS.
That is what the next line is for... (serg)
*/ */
share->state.key_map= ((((ulonglong) 1L << share->base.keys)-1) & share->state.key_map= ((((ulonglong) 1L << share->base.keys)-1) &
@ -1737,8 +1738,22 @@ err:
type,my_errno); type,my_errno);
DBUG_RETURN(1); DBUG_RETURN(1);
} }
/* Fix table or given index using sorting */
/* saves new table in temp_filename */
/*
Repair table or given index using sorting
SYNOPSIS
mi_repair_by_sort()
param Repair parameters
info MyISAM handler to repair
name Name of table (for warnings)
rep_quick set to <> 0 if we should not change data file
RESULT
0 ok
<>0 Error
*/
int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info, int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
const char * name, int rep_quick) const char * name, int rep_quick)
@ -1956,8 +1971,8 @@ int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
goto err; goto err;
} }
} }
share->state.state.data_file_length = info->state->data_file_length share->state.state.data_file_length = info->state->data_file_length=
= sort_param.filepos; sort_param.filepos;
/* Only whole records */ /* Only whole records */
share->state.version=(ulong) time((time_t*) 0); share->state.version=(ulong) time((time_t*) 0);
my_close(info->dfile,MYF(0)); my_close(info->dfile,MYF(0));
@ -2079,19 +2094,35 @@ err:
DBUG_RETURN(got_error); DBUG_RETURN(got_error);
} }
/* same as mi_repair_by_sort */ /*
/* but do it multithreaded */ Threaded repair of table using sorting
SYNOPSIS
mi_repair_by_sort_r()
param Repair parameters
info MyISAM handler to repair
name Name of table (for warnings)
rep_quick set to <> 0 if we should not change data file
DESCRIPTION
Same as mi_repair_by_sort but do it multithreaded
Each key is handled by a separate thread.
RESULT
0 ok
<>0 Error
*/
int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info, int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
const char * name, int rep_quick) const char * name, int rep_quick)
{ {
int got_error; int got_error;
uint i,key; uint i,key, total_key_length;
ulong length; ulong rec_length;
ha_rows start_records; ha_rows start_records;
my_off_t new_header_length,del; my_off_t new_header_length,del;
File new_file; File new_file;
MI_SORT_PARAM *sort_param=0, *sinfo; MI_SORT_PARAM *sort_param=0;
MYISAM_SHARE *share=info->s; MYISAM_SHARE *share=info->s;
ulong *rec_per_key_part; ulong *rec_per_key_part;
MI_KEYSEG *keyseg; MI_KEYSEG *keyseg;
@ -2193,14 +2224,14 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
my_seek(param->read_cache.file,0L,MY_SEEK_END,MYF(0)); my_seek(param->read_cache.file,0L,MY_SEEK_END,MYF(0));
if (share->data_file_type == DYNAMIC_RECORD) if (share->data_file_type == DYNAMIC_RECORD)
length=max(share->base.min_pack_length+1,share->base.min_block_length); rec_length=max(share->base.min_pack_length+1,share->base.min_block_length);
else if (share->data_file_type == COMPRESSED_RECORD) else if (share->data_file_type == COMPRESSED_RECORD)
length=share->base.min_block_length; rec_length=share->base.min_block_length;
else else
length=share->base.pack_reclength; rec_length=share->base.pack_reclength;
sort_info.max_records= sort_info.max_records=
((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records : ((param->testflag & T_CREATE_MISSING_KEYS) ? info->state->records :
(ha_rows) (sort_info.filelength/length+1)); (ha_rows) (sort_info.filelength/rec_length+1));
del=info->state->del; del=info->state->del;
param->glob_crc=0; param->glob_crc=0;
@ -2209,13 +2240,13 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
if (!(sort_param=(MI_SORT_PARAM *) if (!(sort_param=(MI_SORT_PARAM *)
my_malloc((uint) share->base.keys * my_malloc((uint) share->base.keys *
(sizeof(MI_SORT_PARAM) + share->base.pack_reclength), (sizeof(MI_SORT_PARAM) + share->base.pack_reclength),
MYF(MY_ZEROFILL)))) MYF(MY_ZEROFILL))))
{ {
mi_check_print_error(param,"Not enough memory!"); mi_check_print_error(param,"Not enough memory!");
goto err; goto err;
} }
length=0; total_key_length=0;
rec_per_key_part= param->rec_per_key_part; rec_per_key_part= param->rec_per_key_part;
info->state->records=info->state->del=share->state.split=0; info->state->records=info->state->del=share->state.split=0;
info->state->empty=0; info->state->empty=0;
@ -2235,10 +2266,8 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
i--; i--;
continue; continue;
} }
if ((!(param->testflag & T_SILENT))) sort_param[i].key_read= ((sort_param[i].keyinfo->flag & HA_FULLTEXT) ?
printf ("- Fixing index %d\n",key+1); sort_ft_key_read : sort_key_read);
sort_param[i].key_read=(sort_param[i].keyinfo->flag & HA_FULLTEXT) ?
sort_ft_key_read : sort_key_read;
sort_param[i].key_cmp=sort_key_cmp; sort_param[i].key_cmp=sort_key_cmp;
sort_param[i].key_write=sort_key_write; sort_param[i].key_write=sort_key_write;
sort_param[i].lock_in_memory=lock_memory; sort_param[i].lock_in_memory=lock_memory;
@ -2249,12 +2278,12 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
sort_param[i].filepos=new_header_length; sort_param[i].filepos=new_header_length;
sort_param[i].max_pos=sort_param[i].pos=share->pack.header_length; sort_param[i].max_pos=sort_param[i].pos=share->pack.header_length;
sort_param[i].record=((char *)(sort_param+share->base.keys))+ sort_param[i].record= (((char *)(sort_param+share->base.keys))+
(share->base.pack_reclength * i); (share->base.pack_reclength * i));
sort_param[i].key_length=share->rec_reflength; sort_param[i].key_length=share->rec_reflength;
for (keyseg=sort_param[i].keyinfo->seg; keyseg->type != HA_KEYTYPE_END; for (keyseg=sort_param[i].keyinfo->seg; keyseg->type != HA_KEYTYPE_END;
keyseg++) keyseg++)
{ {
sort_param[i].key_length+=keyseg->length; sort_param[i].key_length+=keyseg->length;
if (keyseg->flag & HA_SPACE_PACK) if (keyseg->flag & HA_SPACE_PACK)
@ -2264,8 +2293,7 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
if (keyseg->flag & HA_NULL_PART) if (keyseg->flag & HA_NULL_PART)
sort_param[i].key_length++; sort_param[i].key_length++;
} }
total_key_length+=sort_param[i].key_length;
length+=sort_param[i].key_length;
if (sort_param[i].keyinfo->flag & HA_FULLTEXT) if (sort_param[i].keyinfo->flag & HA_FULLTEXT)
sort_param[i].key_length+=ft_max_word_len_for_sort-ft_max_word_len; sort_param[i].key_length+=ft_max_word_len_for_sort-ft_max_word_len;
@ -2274,12 +2302,12 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
sort_param[0].fix_datafile= ! rep_quick; sort_param[0].fix_datafile= ! rep_quick;
sort_info.got_error=0; sort_info.got_error=0;
pthread_mutex_init(& sort_info.mutex, MY_MUTEX_INIT_FAST); pthread_mutex_init(&sort_info.mutex, MY_MUTEX_INIT_FAST);
pthread_cond_init(& sort_info.cond, 0); pthread_cond_init(&sort_info.cond, 0);
pthread_mutex_lock(& sort_info.mutex); pthread_mutex_lock(&sort_info.mutex);
init_io_cache_share(& param->read_cache, &io_share, i); init_io_cache_share(&param->read_cache, &io_share, i);
for (i=0 ; i<sort_info.total_keys ; i++) for (i=0 ; i < sort_info.total_keys ; i++)
{ {
sort_param[i].read_cache=param->read_cache; sort_param[i].read_cache=param->read_cache;
sort_param[i].sortbuff_size= sort_param[i].sortbuff_size=
@ -2292,13 +2320,13 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
#if 1 #if 1
param->sort_buffer_length/sort_info.total_keys; param->sort_buffer_length/sort_info.total_keys;
#else #else
param->sort_buffer_length*sort_param[i].key_length/length; param->sort_buffer_length*sort_param[i].key_length/total_key_length;
#endif #endif
if (pthread_create(& sort_param[i].thr, 0, if (pthread_create(& sort_param[i].thr, 0,
(void *(*)(void*))_thr_find_all_keys, sort_param+i)) (void *(*)(void*))_thr_find_all_keys, sort_param+i))
{ {
mi_check_print_error(param,"Cannot start a repair thread"); mi_check_print_error(param,"Cannot start a repair thread");
remove_io_thread(& param->read_cache); remove_io_thread(&param->read_cache);
sort_info.got_error=1; sort_info.got_error=1;
} }
else else
@ -2307,17 +2335,17 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
/* waiting for all threads to finish */ /* waiting for all threads to finish */
while (sort_info.threads_running) while (sort_info.threads_running)
pthread_cond_wait(& sort_info.cond, &sort_info.mutex); pthread_cond_wait(&sort_info.cond, &sort_info.mutex);
pthread_mutex_unlock(& sort_info.mutex); pthread_mutex_unlock(&sort_info.mutex);
if (got_error=_thr_write_keys(sort_param)) if ((got_error= _thr_write_keys(sort_param)))
{ {
param->retry_repair=1; param->retry_repair=1;
goto err; goto err;
} }
got_error=1; got_error=1; /* Assume the following may go wrong */
if (sort_param[0].fix_datafile) if (sort_param->fix_datafile)
{ {
if (write_data_suffix(&sort_info,1) || end_io_cache(&info->rec_cache)) if (write_data_suffix(&sort_info,1) || end_io_cache(&info->rec_cache))
goto err; goto err;
@ -2330,8 +2358,8 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
goto err; goto err;
} }
} }
share->state.state.data_file_length = info->state->data_file_length share->state.state.data_file_length= info->state->data_file_length=
= sort_param->filepos; sort_param->filepos;
/* Only whole records */ /* Only whole records */
share->state.version=(ulong) time((time_t*) 0); share->state.version=(ulong) time((time_t*) 0);
my_close(info->dfile,MYF(0)); my_close(info->dfile,MYF(0));
@ -2372,7 +2400,7 @@ int mi_repair_by_sort_r(MI_CHECK *param, register MI_INFO *info,
if (my_chsize(share->kfile,info->state->key_file_length,MYF(0))) if (my_chsize(share->kfile,info->state->key_file_length,MYF(0)))
mi_check_print_warning(param, mi_check_print_warning(param,
"Can't change size of indexfile, error: %d", my_errno); "Can't change size of indexfile, error: %d", my_errno);
if (!(param->testflag & T_SILENT)) if (!(param->testflag & T_SILENT))
{ {
@ -2424,8 +2452,8 @@ err:
share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS; share->state.changed&= ~STATE_NOT_OPTIMIZED_KEYS;
share->state.changed|=STATE_NOT_SORTED_PAGES; share->state.changed|=STATE_NOT_SORTED_PAGES;
pthread_cond_destroy (& sort_info.cond); pthread_cond_destroy (&sort_info.cond);
pthread_mutex_destroy(& sort_info.mutex); pthread_mutex_destroy(&sort_info.mutex);
my_free((gptr) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR)); my_free((gptr) sort_info.key_block,MYF(MY_ALLOW_ZERO_PTR));
my_free((gptr) sort_param,MYF(MY_ALLOW_ZERO_PTR)); my_free((gptr) sort_param,MYF(MY_ALLOW_ZERO_PTR));
@ -2457,9 +2485,10 @@ static int sort_key_read(MI_SORT_PARAM *sort_param, void *key)
"Found too many records; Can`t continue"); "Found too many records; Can`t continue");
DBUG_RETURN(1); DBUG_RETURN(1);
} }
sort_param->real_key_length=(info->s->rec_reflength+ sort_param->real_key_length=
_mi_make_key(info, sort_param->key, (uchar*) key, (info->s->rec_reflength+
sort_param->record, sort_param->filepos)); _mi_make_key(info, sort_param->key, (uchar*) key,
sort_param->record, sort_param->filepos));
DBUG_RETURN(sort_write_record(sort_param)); DBUG_RETURN(sort_write_record(sort_param));
} /* sort_key_read */ } /* sort_key_read */
@ -2981,7 +3010,8 @@ int sort_write_record(MI_SORT_PARAM *sort_param)
/* Compare two keys from _create_index_by_sort */ /* Compare two keys from _create_index_by_sort */
static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a, const void *b) static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,
const void *b)
{ {
uint not_used; uint not_used;
return (_mi_key_cmp(sort_param->keyinfo->seg,*((uchar**) a),*((uchar**) b), return (_mi_key_cmp(sort_param->keyinfo->seg,*((uchar**) a),*((uchar**) b),
@ -2999,8 +3029,9 @@ static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
if (sort_info->key_block->inited) if (sort_info->key_block->inited)
{ {
cmp=_mi_key_cmp(sort_param->keyinfo->seg,sort_info->key_block->lastkey, cmp=_mi_key_cmp(sort_param->keyinfo->seg, sort_info->key_block->lastkey,
(uchar*) a, USE_WHOLE_KEY,SEARCH_FIND | SEARCH_UPDATE ,&diff_pos); (uchar*) a, USE_WHOLE_KEY, SEARCH_FIND | SEARCH_UPDATE,
&diff_pos);
sort_param->unique[diff_pos-1]++; sort_param->unique[diff_pos-1]++;
} }
else else
@ -3032,7 +3063,7 @@ static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
} }
#endif #endif
return (sort_insert_key(sort_param,sort_info->key_block, return (sort_insert_key(sort_param,sort_info->key_block,
(uchar*) a, HA_OFFSET_ERROR)); (uchar*) a, HA_OFFSET_ERROR));
} /* sort_key_write */ } /* sort_key_write */
@ -3448,7 +3479,7 @@ int write_data_suffix(SORT_INFO *sort_info, my_bool fix_datafile)
if (my_b_write(&info->rec_cache,buff,sizeof(buff))) if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
{ {
mi_check_print_error(sort_info->param, mi_check_print_error(sort_info->param,
"%d when writing to datafile",my_errno); "%d when writing to datafile",my_errno);
return 1; return 1;
} }
sort_info->param->read_cache.end_of_file+=sizeof(buff); sort_info->param->read_cache.end_of_file+=sizeof(buff);
@ -3638,8 +3669,7 @@ void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows)
*/ */
my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows,
ulonglong key_map, ulonglong key_map, my_bool force)
my_bool force)
{ {
MYISAM_SHARE *share=info->s; MYISAM_SHARE *share=info->s;
MI_KEYDEF *key=share->keyinfo; MI_KEYDEF *key=share->keyinfo;

163
myisam/sort.c
View File

@ -27,7 +27,8 @@
#endif #endif
#include <queues.h> #include <queues.h>
/* static variables */ /* static variables */
#undef MIN_SORT_MEMORY #undef MIN_SORT_MEMORY
#undef MYF_RW #undef MYF_RW
#undef DISK_BUFFER_SIZE #undef DISK_BUFFER_SIZE
@ -48,7 +49,7 @@ typedef struct st_buffpek {
extern void print_error _VARARGS((const char *fmt,...)); extern void print_error _VARARGS((const char *fmt,...));
/* functions defined in this file */ /* Functions defined in this file */
static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info,uint keys, static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info,uint keys,
uchar **sort_keys, uchar **sort_keys,
@ -57,7 +58,8 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info,uint keys,
IO_CACHE *tempfile_for_exceptions); IO_CACHE *tempfile_for_exceptions);
static int NEAR_F write_keys(MI_SORT_PARAM *info,uchar * *sort_keys, static int NEAR_F write_keys(MI_SORT_PARAM *info,uchar * *sort_keys,
uint count, BUFFPEK *buffpek,IO_CACHE *tempfile); uint count, BUFFPEK *buffpek,IO_CACHE *tempfile);
static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile); static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key,
IO_CACHE *tempfile);
static int NEAR_F write_index(MI_SORT_PARAM *info,uchar * *sort_keys, static int NEAR_F write_index(MI_SORT_PARAM *info,uchar * *sort_keys,
uint count); uint count);
static int NEAR_F merge_many_buff(MI_SORT_PARAM *info,uint keys, static int NEAR_F merge_many_buff(MI_SORT_PARAM *info,uint keys,
@ -72,8 +74,21 @@ static int NEAR_F merge_buffers(MI_SORT_PARAM *info,uint keys,
BUFFPEK *Fb, BUFFPEK *Tb); BUFFPEK *Fb, BUFFPEK *Tb);
static int NEAR_F merge_index(MI_SORT_PARAM *,uint,uchar **,BUFFPEK *, int, static int NEAR_F merge_index(MI_SORT_PARAM *,uint,uchar **,BUFFPEK *, int,
IO_CACHE *); IO_CACHE *);
/* Creates a index of sorted keys */
/* Returns 0 if everything went ok */
/*
Creates a index of sorted keys
SYNOPSIS
_create_index_by_sort()
info Sort parameters
no_messages Set to 1 if no output
sortbuff_size Size if sortbuffer to allocate
RESULT
0 ok
<> 0 Error
*/
int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages, int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages,
ulong sortbuff_size) ulong sortbuff_size)
@ -209,7 +224,7 @@ err:
} /* _create_index_by_sort */ } /* _create_index_by_sort */
/* Search after all keys and place them in a temp. file */ /* Search after all keys and place them in a temp. file */
static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys, static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
uchar **sort_keys, DYNAMIC_ARRAY *buffpek, uchar **sort_keys, DYNAMIC_ARRAY *buffpek,
@ -223,7 +238,7 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
idx=error=0; idx=error=0;
sort_keys[0]=(uchar*) (sort_keys+keys); sort_keys[0]=(uchar*) (sort_keys+keys);
while(!(error=(*info->key_read)(info,sort_keys[idx]))) while (!(error=(*info->key_read)(info,sort_keys[idx])))
{ {
if (info->real_key_length > info->key_length) if (info->real_key_length > info->key_length)
{ {
@ -248,7 +263,8 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
DBUG_RETURN(HA_POS_ERROR); /* Aborted by get_key */ /* purecov: inspected */ DBUG_RETURN(HA_POS_ERROR); /* Aborted by get_key */ /* purecov: inspected */
if (buffpek->elements) if (buffpek->elements)
{ {
if (write_keys(info,sort_keys,idx,(BUFFPEK *)alloc_dynamic(buffpek),tempfile)) if (write_keys(info,sort_keys,idx,(BUFFPEK *)alloc_dynamic(buffpek),
tempfile))
DBUG_RETURN(HA_POS_ERROR); /* purecov: inspected */ DBUG_RETURN(HA_POS_ERROR); /* purecov: inspected */
*maxbuffer=buffpek->elements-1; *maxbuffer=buffpek->elements-1;
} }
@ -258,21 +274,22 @@ static ha_rows NEAR_F find_all_keys(MI_SORT_PARAM *info, uint keys,
DBUG_RETURN((*maxbuffer)*(keys-1)+idx); DBUG_RETURN((*maxbuffer)*(keys-1)+idx);
} /* find_all_keys */ } /* find_all_keys */
/* Search after all keys and place them in a temp. file */
/* Search after all keys and place them in a temp. file */
void *_thr_find_all_keys(MI_SORT_PARAM *info) void *_thr_find_all_keys(MI_SORT_PARAM *info)
{ {
int error,skr; int error;
uint memavl,old_memavl,keys,sort_length; uint memavl,old_memavl,keys,sort_length;
uint idx, maxbuffer; uint idx, maxbuffer;
uchar **sort_keys; uchar **sort_keys;
MI_KEYSEG *keyseg;
my_b_clear(&info->tempfile); my_b_clear(&info->tempfile);
my_b_clear(&info->tempfile_for_exceptions); my_b_clear(&info->tempfile_for_exceptions);
bzero((char*) &info->buffpek,sizeof(info->buffpek)); bzero((char*) &info->buffpek,sizeof(info->buffpek));
bzero((char*) &info->unique, sizeof(info->unique)); bzero((char*) &info->unique, sizeof(info->unique));
sort_keys= (uchar **) NULL; error= 1; sort_keys= (uchar **) NULL;
error= 1;
if (info->sort_info->got_error) if (info->sort_info->got_error)
goto err; goto err;
@ -280,12 +297,15 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
idx= info->sort_info->max_records; idx= info->sort_info->max_records;
sort_length= info->key_length; sort_length= info->key_length;
maxbuffer=1;
while (memavl >= MIN_SORT_MEMORY) while (memavl >= MIN_SORT_MEMORY)
{ {
if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <= if ((my_off_t) (idx+1)*(sort_length+sizeof(char*)) <=
(my_off_t) memavl) (my_off_t) memavl)
keys= idx+1; keys= idx+1;
else else
{
uint skr;
do do
{ {
skr=maxbuffer; skr=maxbuffer;
@ -299,12 +319,13 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
} }
} }
while ((maxbuffer= (int) (idx/(keys-1)+1)) != skr); while ((maxbuffer= (int) (idx/(keys-1)+1)) != skr);
}
if ((sort_keys=(uchar **)my_malloc(keys*(sort_length+sizeof(char*))+ if ((sort_keys=(uchar **)my_malloc(keys*(sort_length+sizeof(char*))+
((info->keyinfo->flag & HA_FULLTEXT) ? HA_FT_MAXLEN : 0), MYF(0)))) ((info->keyinfo->flag & HA_FULLTEXT) ?
HA_FT_MAXLEN : 0), MYF(0))))
{ {
if (my_init_dynamic_array(&info->buffpek, sizeof(BUFFPEK), if (my_init_dynamic_array(&info->buffpek, sizeof(BUFFPEK),
maxbuffer, maxbuffer/2)) maxbuffer, maxbuffer/2))
my_free((gptr) sort_keys,MYF(0)); my_free((gptr) sort_keys,MYF(0));
else else
break; break;
@ -318,7 +339,6 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
mi_check_print_error(info->sort_info->param,"Sort buffer to small"); /* purecov: tested */ mi_check_print_error(info->sort_info->param,"Sort buffer to small"); /* purecov: tested */
goto err; /* purecov: tested */ goto err; /* purecov: tested */
} }
// (*info->lock_in_memory)(info->sort_info->param);/* Everything is allocated */
if (info->sort_info->param->testflag & T_VERBOSE) if (info->sort_info->param->testflag & T_VERBOSE)
printf("Key %d - Allocating buffer for %d keys\n",info->key+1,keys); printf("Key %d - Allocating buffer for %d keys\n",info->key+1,keys);
@ -327,12 +347,12 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
idx=error=0; idx=error=0;
sort_keys[0]=(uchar*) (sort_keys+keys); sort_keys[0]=(uchar*) (sort_keys+keys);
while(!(error=info->sort_info->got_error) || while (!(error=info->sort_info->got_error) ||
!(error=(*info->key_read)(info,sort_keys[idx]))) !(error=(*info->key_read)(info,sort_keys[idx])))
{ {
if (info->real_key_length > info->key_length) if (info->real_key_length > info->key_length)
{ {
if (write_key(info,sort_keys[idx],& info->tempfile_for_exceptions)) if (write_key(info,sort_keys[idx], &info->tempfile_for_exceptions))
goto err; goto err;
continue; continue;
} }
@ -340,7 +360,8 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
if (++idx == keys) if (++idx == keys)
{ {
if (write_keys(info,sort_keys,idx-1, if (write_keys(info,sort_keys,idx-1,
(BUFFPEK *)alloc_dynamic(&info->buffpek), &info->tempfile)) (BUFFPEK *)alloc_dynamic(&info->buffpek),
&info->tempfile))
goto err; goto err;
sort_keys[0]=(uchar*) (sort_keys+keys); sort_keys[0]=(uchar*) (sort_keys+keys);
@ -353,8 +374,8 @@ void *_thr_find_all_keys(MI_SORT_PARAM *info)
goto err; goto err;
if (info->buffpek.elements) if (info->buffpek.elements)
{ {
if (write_keys(info,sort_keys,idx,(BUFFPEK *) if (write_keys(info,sort_keys, idx,
alloc_dynamic(&info->buffpek),&info->tempfile)) (BUFFPEK *) alloc_dynamic(&info->buffpek), &info->tempfile))
goto err; goto err;
info->keys=(info->buffpek.elements-1)*(keys-1)+idx; info->keys=(info->buffpek.elements-1)*(keys-1)+idx;
} }
@ -370,31 +391,36 @@ err:
my_free((gptr) sort_keys,MYF(0)); my_free((gptr) sort_keys,MYF(0));
info->sort_keys=0; info->sort_keys=0;
delete_dynamic(& info->buffpek); delete_dynamic(& info->buffpek);
close_cached_file(& info->tempfile); close_cached_file(&info->tempfile);
close_cached_file(& info->tempfile_for_exceptions); close_cached_file(&info->tempfile_for_exceptions);
ok: ok:
remove_io_thread(& info->read_cache); remove_io_thread(&info->read_cache);
pthread_mutex_lock(& info->sort_info->mutex); pthread_mutex_lock(&info->sort_info->mutex);
info->sort_info->threads_running--; info->sort_info->threads_running--;
pthread_cond_signal(& info->sort_info->cond); pthread_cond_signal(&info->sort_info->cond);
pthread_mutex_unlock(& info->sort_info->mutex); pthread_mutex_unlock(&info->sort_info->mutex);
return NULL; return NULL;
} /* _thr_find_all_keys */ } /* _thr_find_all_keys */
int _thr_write_keys(MI_SORT_PARAM *sort_param) int _thr_write_keys(MI_SORT_PARAM *sort_param)
{ {
SORT_INFO *sort_info=sort_param->sort_info; SORT_INFO *sort_info=sort_param->sort_info;
MI_CHECK *param=sort_info->param; MI_CHECK *param=sort_info->param;
ulong length, keys; ulong length, keys;
ulong *rec_per_key_part=param->rec_per_key_part; ulong *rec_per_key_part=param->rec_per_key_part;
int i, got_error=sort_info->got_error; int got_error=sort_info->got_error;
uint i;
MI_INFO *info=sort_info->info; MI_INFO *info=sort_info->info;
MYISAM_SHARE *share=info->s; MYISAM_SHARE *share=info->s;
MI_SORT_PARAM *sinfo; MI_SORT_PARAM *sinfo;
byte *mergebuf=0; byte *mergebuf=0;
LINT_INIT(length);
for (i=0, sinfo=sort_param ; i<sort_info->total_keys ; i++, sinfo++, for (i=0, sinfo=sort_param ;
rec_per_key_part+=sinfo->keyinfo->keysegs) i < sort_info->total_keys ;
i++, sinfo++, rec_per_key_part+=sinfo->keyinfo->keysegs)
{ {
if (!sinfo->sort_keys) if (!sinfo->sort_keys)
{ {
@ -404,25 +430,30 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
share->state.key_map|=(ulonglong) 1 << sinfo->key; share->state.key_map|=(ulonglong) 1 << sinfo->key;
if (param->testflag & T_STATISTICS) if (param->testflag & T_STATISTICS)
update_key_parts(sinfo->keyinfo, rec_per_key_part, update_key_parts(sinfo->keyinfo, rec_per_key_part,
sinfo->unique, (ulonglong) info->state->records); sinfo->unique, (ulonglong) info->state->records);
if (!sinfo->buffpek.elements) if (!sinfo->buffpek.elements)
{ {
if (param->testflag & T_VERBOSE) if (param->testflag & T_VERBOSE)
printf("Key %d - Dumping %lu keys\n",sinfo->key+1, sinfo->keys); {
if (write_index(sinfo,sinfo->sort_keys,(uint) sinfo->keys) || printf("Key %d - Dumping %u keys\n",sinfo->key+1, sinfo->keys);
flush_pending_blocks(sinfo)) fflush(stdout);
}
if (write_index(sinfo, sinfo->sort_keys, sinfo->keys) ||
flush_pending_blocks(sinfo))
got_error=1; got_error=1;
} }
my_free((gptr) sinfo->sort_keys,MYF(0)); my_free((gptr) sinfo->sort_keys,MYF(0));
sinfo->sort_keys=0; sinfo->sort_keys=0;
} }
for (i=0, sinfo=sort_param ; i<sort_info->total_keys ; i++, sinfo++, for (i=0, sinfo=sort_param ;
delete_dynamic(& sinfo->buffpek), i < sort_info->total_keys ;
close_cached_file(& sinfo->tempfile), i++, sinfo++, delete_dynamic(&sinfo->buffpek),
close_cached_file(& sinfo->tempfile_for_exceptions)) close_cached_file(&sinfo->tempfile),
close_cached_file(&sinfo->tempfile_for_exceptions))
{ {
if (got_error) continue; if (got_error)
continue;
if (sinfo->buffpek.elements) if (sinfo->buffpek.elements)
{ {
uint maxbuffer=sinfo->buffpek.elements-1; uint maxbuffer=sinfo->buffpek.elements-1;
@ -444,10 +475,10 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
if (maxbuffer >= MERGEBUFF2) if (maxbuffer >= MERGEBUFF2)
{ {
if (param->testflag & T_VERBOSE) if (param->testflag & T_VERBOSE)
printf("Key %d - Merging %lu keys\n",sinfo->key+1, sinfo->keys); printf("Key %d - Merging %u keys\n",sinfo->key+1, sinfo->keys);
if (merge_many_buff(sinfo, keys, (uchar **)mergebuf, if (merge_many_buff(sinfo, keys, (uchar **)mergebuf,
dynamic_element(&sinfo->buffpek, 0, BUFFPEK *), dynamic_element(&sinfo->buffpek, 0, BUFFPEK *),
&maxbuffer, &sinfo->tempfile)) &maxbuffer, &sinfo->tempfile))
{ {
got_error=1; got_error=1;
continue; continue;
@ -463,8 +494,8 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
printf("Key %d - Last merge and dumping keys", sinfo->key+1); printf("Key %d - Last merge and dumping keys", sinfo->key+1);
if (merge_index(sinfo, keys, (uchar **)mergebuf, if (merge_index(sinfo, keys, (uchar **)mergebuf,
dynamic_element(&sinfo->buffpek,0,BUFFPEK *), dynamic_element(&sinfo->buffpek,0,BUFFPEK *),
maxbuffer,&sinfo->tempfile) maxbuffer,&sinfo->tempfile) ||
|| flush_pending_blocks(sinfo)) flush_pending_blocks(sinfo))
{ {
got_error=1; got_error=1;
continue; continue;
@ -484,15 +515,15 @@ int _thr_write_keys(MI_SORT_PARAM *sort_param)
continue; continue;
} }
while (!got_error while (!got_error &&
&& !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)&key_length, !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)&key_length,
sizeof(key_length)) sizeof(key_length)) &&
&& !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)mergebuf, !my_b_read(&sinfo->tempfile_for_exceptions,(byte*)mergebuf,
(uint) key_length)) (uint) key_length))
{ {
if (_mi_ck_write(info,sinfo->key,(uchar*) mergebuf, if (_mi_ck_write(info,sinfo->key,(uchar*) mergebuf,
key_length - info->s->rec_reflength)) key_length - info->s->rec_reflength))
got_error=1; got_error=1;
} }
} }
} }
@ -526,7 +557,8 @@ static int NEAR_F write_keys(MI_SORT_PARAM *info, register uchar **sort_keys,
} /* write_keys */ } /* write_keys */
static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile) static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key,
IO_CACHE *tempfile)
{ {
uint key_length=info->real_key_length; uint key_length=info->real_key_length;
DBUG_ENTER("write_key"); DBUG_ENTER("write_key");
@ -542,6 +574,7 @@ static int NEAR_F write_key(MI_SORT_PARAM *info, uchar *key, IO_CACHE *tempfile)
DBUG_RETURN(0); DBUG_RETURN(0);
} /* write_key */ } /* write_key */
/* Write index */ /* Write index */
static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys, static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
@ -552,8 +585,10 @@ static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
qsort2((gptr) sort_keys,(size_t) count,sizeof(byte*), qsort2((gptr) sort_keys,(size_t) count,sizeof(byte*),
(qsort2_cmp) info->key_cmp,info); (qsort2_cmp) info->key_cmp,info);
while (count--) while (count--)
{
if ((*info->key_write)(info,*sort_keys++)) if ((*info->key_write)(info,*sort_keys++))
DBUG_RETURN(-1); /* purecov: inspected */ DBUG_RETURN(-1); /* purecov: inspected */
}
DBUG_RETURN(0); DBUG_RETURN(0);
} /* write_index */ } /* write_index */
@ -604,8 +639,18 @@ static int NEAR_F merge_many_buff(MI_SORT_PARAM *info, uint keys,
} /* merge_many_buff */ } /* merge_many_buff */
/* Read data to buffer */ /*
/* This returns (uint) -1 if something goes wrong */ Read data to buffer
SYNOPSIS
read_to_buffer()
fromfile File to read from
buffpek Where to read from
sort_length max length to read
RESULT
> 0 Ammount of bytes read
-1 Error
*/
static uint NEAR_F read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek, static uint NEAR_F read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
uint sort_length) uint sort_length)
@ -627,8 +672,10 @@ static uint NEAR_F read_to_buffer(IO_CACHE *fromfile, BUFFPEK *buffpek,
} /* read_to_buffer */ } /* read_to_buffer */
/* Merge buffers to one buffer */ /*
/* If to_file == 0 then use info->key_write */ Merge buffers to one buffer
If to_file == 0 then use info->key_write
*/
static int NEAR_F static int NEAR_F
merge_buffers(MI_SORT_PARAM *info, uint keys, IO_CACHE *from_file, merge_buffers(MI_SORT_PARAM *info, uint keys, IO_CACHE *from_file,

6
myisammrg/myrg_delete.c
View File

@ -18,12 +18,10 @@
#include "myrg_def.h" #include "myrg_def.h"
int myrg_delete( int myrg_delete(MYRG_INFO *info, const byte *record)
MYRG_INFO *info,
const byte *record)
{ {
if (!info->current_table) if (!info->current_table)
return my_errno=HA_ERR_NO_ACTIVE_RECORD ; return (my_errno= HA_ERR_NO_ACTIVE_RECORD);
return mi_delete(info->current_table->table,record); return mi_delete(info->current_table->table,record);
} }

4
myisammrg/myrg_rsame.c
View File

@ -19,10 +19,10 @@
int myrg_rsame(MYRG_INFO *info,byte *record,int inx) int myrg_rsame(MYRG_INFO *info,byte *record,int inx)
{ {
if (inx) /* not yet used, should be 0 */ if (inx) /* not yet used, should be 0 */
return my_errno=HA_ERR_WRONG_INDEX; return (my_errno=HA_ERR_WRONG_INDEX);
if (!info->current_table) if (!info->current_table)
return my_errno=HA_ERR_NO_ACTIVE_RECORD; return (my_errno=HA_ERR_NO_ACTIVE_RECORD);
return mi_rsame(info->current_table->table,record,inx); return mi_rsame(info->current_table->table,record,inx);
} }

2
myisammrg/myrg_update.c
View File

@ -21,7 +21,7 @@
int myrg_update(register MYRG_INFO *info,const byte *oldrec, byte *newrec) int myrg_update(register MYRG_INFO *info,const byte *oldrec, byte *newrec)
{ {
if (!info->current_table) if (!info->current_table)
return my_errno=HA_ERR_NO_ACTIVE_RECORD; return (my_errno=HA_ERR_NO_ACTIVE_RECORD);
return mi_update(info->current_table->table,oldrec,newrec); return mi_update(info->current_table->table,oldrec,newrec);
} }

2
myisammrg/myrg_write.c
View File

@ -26,5 +26,5 @@ int myrg_write(register MYRG_INFO *info, byte *rec)
else if (info->merge_insert_method == MERGE_INSERT_TO_LAST) else if (info->merge_insert_method == MERGE_INSERT_TO_LAST)
return mi_write(info->end_table[-1].table,rec); return mi_write(info->end_table[-1].table,rec);
else /* unsupported insertion method */ else /* unsupported insertion method */
return my_errno=HA_ERR_WRONG_COMMAND; return (my_errno= HA_ERR_WRONG_COMMAND);
} }

2
mysys/Makefile.am
View File

@ -44,7 +44,7 @@ libmysys_a_SOURCES = my_init.c my_getwd.c mf_getdate.c\
my_delete.c my_rename.c my_redel.c my_tempnam.c \ my_delete.c my_rename.c my_redel.c my_tempnam.c \
my_chsize.c my_lread.c my_lwrite.c my_clock.c \ my_chsize.c my_lread.c my_lwrite.c my_clock.c \
my_quick.c my_lockmem.c my_static.c \ my_quick.c my_lockmem.c my_static.c \
my_getopt.c getvar.c my_mkdir.c \ my_getopt.c my_mkdir.c \
default.c my_compress.c checksum.c raid.cc \ default.c my_compress.c checksum.c raid.cc \
my_net.c \ my_net.c \
my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c \ my_vsnprintf.c charset.c my_bitmap.c my_bit.c md5.c \

111
mysys/getvar.c
View File

@ -1,111 +0,0 @@
/* Copyright (C) 2000 MySQL AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* Allow use of the -O variable= option to set long variables */
#include "mysys_priv.h"
#include <m_string.h>
#include <m_ctype.h>
#include <my_getopt.h>
/* set all changeable variables */
void set_all_changeable_vars(CHANGEABLE_VAR *vars)
{
for ( ; vars->name ; vars++)
*vars->varptr= vars->def_value;
}
my_bool set_changeable_varval(const char* var, ulong val,
CHANGEABLE_VAR *vars)
{
char buffer[256];
sprintf( buffer, "%s=%lu", var, (unsigned long) val );
return set_changeable_var( buffer, vars );
}
my_bool set_changeable_var(my_string str,CHANGEABLE_VAR *vars)
{
char endchar;
my_string end;
DBUG_ENTER("set_changeable_var");
DBUG_PRINT("enter",("%s",str));
if (str)
{
if (!(end=strchr(str,'=')))
fprintf(stderr,"Can't find '=' in expression '%s' to option -O\n",str);
else
{
uint length,found_count=0;
CHANGEABLE_VAR *var,*found;
my_string var_end;
const char *name;
longlong num;
/* Skip end space from variable */
for (var_end=end ; end > str && isspace(var_end[-1]) ; var_end--) ;
length=(uint) (var_end-str);
/* Skip start space from argument */
for (end++ ; isspace(*end) ; end++) ;
for (var=vars,found=0 ; (name=var->name) ; var++)
{
if (!my_casecmp(name,str,length))
{
found=var; found_count++;
if (!name[length])
{
found_count=1;
break;
}
}
}
if (found_count == 0)
{
fprintf(stderr,"No variable match for: -O '%s'\n",str);
DBUG_RETURN(1);
}
if (found_count > 1)
{
fprintf(stderr,"Variable prefix '%*s' is not unique\n",length,str);
DBUG_RETURN(1);
}
num=strtoll(end, (char **)NULL, 10); endchar=strend(end)[-1];
if (endchar == 'k' || endchar == 'K')
num*=1024;
else if (endchar == 'm' || endchar == 'M')
num*=1024L*1024L;
else if (endchar == 'g' || endchar == 'G')
num*=1024L*1024L*1024L;
else if (!isdigit(endchar))
{
fprintf(stderr,"Unknown prefix used for variable value '%s'\n",str);
DBUG_RETURN(1);
}
if (num < (longlong) found->min_value)
num=(longlong) found->min_value;
else if (num > 0 && (ulonglong) num > (ulonglong) (ulong) found->max_value)
num=(longlong) (ulong) found->max_value;
num=((num- (longlong) found->sub_size) / (ulonglong) found->block_size);
(*found->varptr)= (long) (num*(ulonglong) found->block_size);
DBUG_RETURN(0);
}
}
DBUG_RETURN(1);
}

33
sql/field.cc
View File

@ -312,8 +312,8 @@ bool Field::optimize_range(uint idx)
} }
/**************************************************************************** /****************************************************************************
** Functions for the Field_decimal class Functions for the Field_decimal class
** This is an unpacked number. This is an number stored as a pre-space (or pre-zero) string
****************************************************************************/ ****************************************************************************/
void void
@ -326,6 +326,8 @@ void Field_decimal::overflow(bool negative)
{ {
uint len=field_length; uint len=field_length;
char *to=ptr, filler= '9'; char *to=ptr, filler= '9';
current_thd->cuted_fields++;
if (negative) if (negative)
{ {
if (!unsigned_flag) if (!unsigned_flag)
@ -419,7 +421,7 @@ void Field_decimal::store(const char *from,uint len)
if ((tmp_dec=dec)) if ((tmp_dec=dec))
tmp_dec++; tmp_dec++;
for (; from!=end && isspace(*from); from++) ; // Read spaces for (; from !=end && isspace(*from); from++) ; // Read spaces
if (from == end) if (from == end)
{ {
current_thd->cuted_fields++; current_thd->cuted_fields++;
@ -428,23 +430,22 @@ void Field_decimal::store(const char *from,uint len)
else if (*from == '+' || *from == '-') // Found some sign ? else if (*from == '+' || *from == '-') // Found some sign ?
{ {
sign_char= *from++; sign_char= *from++;
/* /*
Unsigned can't have any flag. So we'll just drop "+" Unsigned can't have any flag. So we'll just drop "+"
and will overflow on "-" and will overflow on "-"
*/ */
if (unsigned_flag) if (unsigned_flag)
{ {
if (sign_char=='-') if (sign_char=='-')
{ {
current_thd->cuted_fields++;
Field_decimal::overflow(1); Field_decimal::overflow(1);
return; return;
} }
else else
sign_char=0; sign_char=0;
} }
} }
pre_zeros_from= from; pre_zeros_from= from;
for (; from!=end && *from == '0'; from++) ; // Read prezeros for (; from!=end && *from == '0'; from++) ; // Read prezeros
pre_zeros_end=int_digits_from=from; pre_zeros_end=int_digits_from=from;
@ -484,7 +485,7 @@ void Field_decimal::store(const char *from,uint len)
if (current_thd->count_cuted_fields) if (current_thd->count_cuted_fields)
{ {
for (;from!=end && isspace(*from); from++) ; // Read end spaces for (;from != end && isspace(*from); from++) ; // Read end spaces
if (from != end) // If still something left, warn if (from != end) // If still something left, warn
{ {
current_thd->cuted_fields++; current_thd->cuted_fields++;
@ -563,7 +564,6 @@ void Field_decimal::store(const char *from,uint len)
if (field_length < tmp_uint + (int) (sign_char == '-')) if (field_length < tmp_uint + (int) (sign_char == '-'))
{ {
current_thd->cuted_fields++;
// too big number, change to max or min number // too big number, change to max or min number
Field_decimal::overflow(sign_char == '-'); Field_decimal::overflow(sign_char == '-');
return; return;
@ -606,7 +606,7 @@ void Field_decimal::store(const char *from,uint len)
} }
else else
{ {
left_wall=to+(sign_char!=0)-1; left_wall=to+(sign_char != 0)-1;
if (!expo_sign_char) // If exponent was specified, ignore prezeros if (!expo_sign_char) // If exponent was specified, ignore prezeros
{ {
for (;pos != left_wall && pre_zeros_from !=pre_zeros_end; for (;pos != left_wall && pre_zeros_from !=pre_zeros_end;
@ -659,7 +659,7 @@ void Field_decimal::store(const char *from,uint len)
{ {
if (tmp_char != '0') // Losing a non zero digit ? if (tmp_char != '0') // Losing a non zero digit ?
{ {
if (current_thd->count_cuted_fields && !is_cuted_fields_incr) if (!is_cuted_fields_incr)
current_thd->cuted_fields++; current_thd->cuted_fields++;
return; return;
} }
@ -696,14 +696,12 @@ void Field_decimal::store(double nr)
if (unsigned_flag && nr < 0) if (unsigned_flag && nr < 0)
{ {
overflow(1); overflow(1);
current_thd->cuted_fields++;
return; return;
} }
if (isinf(nr)) // Handle infinity as special case if (isinf(nr)) // Handle infinity as special case
{ {
overflow(nr < 0.0); overflow(nr < 0.0);
current_thd->cuted_fields++;
return; return;
} }
@ -721,10 +719,7 @@ void Field_decimal::store(double nr)
length=(uint) strlen(buff); length=(uint) strlen(buff);
if (length > field_length) if (length > field_length)
{
overflow(nr < 0.0); overflow(nr < 0.0);
current_thd->cuted_fields++;
}
else else
{ {
to=ptr; to=ptr;
@ -740,7 +735,6 @@ void Field_decimal::store(longlong nr)
if (unsigned_flag && nr < 0) if (unsigned_flag && nr < 0)
{ {
overflow(1); overflow(1);
current_thd->cuted_fields++;
return; return;
} }
char buff[22]; char buff[22];
@ -748,10 +742,7 @@ void Field_decimal::store(longlong nr)
uint int_part=field_length- (dec ? dec+1 : 0); uint int_part=field_length- (dec ? dec+1 : 0);
if (length > int_part) if (length > int_part)
{
overflow(test(nr < 0L)); /* purecov: inspected */ overflow(test(nr < 0L)); /* purecov: inspected */
current_thd->cuted_fields++; /* purecov: inspected */
}
else else
{ {
char fyllchar = zerofill ? (char) '0' : (char) ' '; char fyllchar = zerofill ? (char) '0' : (char) ' ';