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

Merge polly.(none):/home/kaa/src/maint/mysql-5.0-maint

Browse Source 
into  polly.(none):/home/kaa/src/maint/mysql-5.1-maint


include/my_sys.h:
  Auto merged
libmysql/Makefile.shared:
  Auto merged
sql/item_cmpfunc.cc:
  Auto merged
sql/item_cmpfunc.h:
  Auto merged
sql/opt_range.cc:
  Auto merged
sql/records.cc:
  Auto merged
sql/sql_array.h:
  Auto merged
sql/sql_help.cc:
  Auto merged
sql/sql_select.cc:
  Auto merged
storage/myisam/ft_boolean_search.c:
  Auto merged
storage/myisam/ft_nlq_search.c:
  Auto merged
storage/myisam/myisampack.c:
  Auto merged
mysys/mf_keycache.c:
  Manual merge.
mysys/mf_sort.c:
  Manual merge.
mysys/my_lib.c:
  Manual merge.
mysys/queues.c:
  Manual merge.
sql/sql_acl.cc:
  Manual merge.
sql/sql_table.cc:
  Manual merge.
storage/csv/ha_tina.cc:
  Manual merge.
storage/myisam/sort.c:
  Manual merge.
This commit is contained in:
unknown 2007-10-18 14:32:43 +04:00
commit ddaecb2161
21 changed files with 63 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/my_sys.h
View File

@ -710,8 +710,10 @@ extern sig_handler my_set_alarm_variable(int signo);
extern void my_string_ptr_sort(uchar *base, uint items, size_t size); extern void my_string_ptr_sort(uchar *base, uint items, size_t size);
extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements, extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
size_t size_of_element,uchar *buffer[]); size_t size_of_element,uchar *buffer[]);
extern qsort_t qsort2(void *base_ptr, size_t total_elems, size_t size, extern qsort_t my_qsort(void *base_ptr, size_t total_elems, size_t size,
qsort2_cmp cmp, void *cmp_argument); qsort_cmp cmp);
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
qsort2_cmp cmp, void *cmp_argument);
extern qsort2_cmp get_ptr_compare(size_t); extern qsort2_cmp get_ptr_compare(size_t);
void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos); void my_store_ptr(uchar *buff, size_t pack_length, my_off_t pos);
my_off_t my_get_ptr(uchar *ptr, size_t pack_length); my_off_t my_get_ptr(uchar *ptr, size_t pack_length);

2
libmysql/Makefile.shared
View File

@ -73,7 +73,7 @@ sqlobjects = net.lo
sql_cmn_objects = pack.lo client.lo my_time.lo sql_cmn_objects = pack.lo client.lo my_time.lo
# Not needed in the minimum library # Not needed in the minimum library
mysysobjects2 = my_lib.lo mysysobjects2 = my_lib.lo mf_qsort.lo
mysysobjects = $(mysysobjects1) $(mysysobjects2) mysysobjects = $(mysysobjects1) $(mysysobjects2)
target_libadd = $(mysysobjects) $(mystringsobjects) $(dbugobjects) \ target_libadd = $(mysysobjects) $(mystringsobjects) $(dbugobjects) \
$(sql_cmn_objects) $(vio_objects) $(sqlobjects) $(sql_cmn_objects) $(vio_objects) $(sqlobjects)

2
mysys/mf_keycache.c
View File

@ -3429,7 +3429,7 @@ static int flush_cached_blocks(KEY_CACHE *keycache,
As all blocks referred in 'cache' are marked by BLOCK_IN_FLUSH As all blocks referred in 'cache' are marked by BLOCK_IN_FLUSH
we are guarunteed no thread will change them we are guarunteed no thread will change them
*/ */
qsort((uchar*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link); my_qsort((uchar*) cache, count, sizeof(*cache), (qsort_cmp) cmp_sec_link);
keycache_pthread_mutex_lock(&keycache->cache_lock); keycache_pthread_mutex_lock(&keycache->cache_lock);
/* /*

4
mysys/mf_qsort.c
View File

@ -91,10 +91,10 @@ typedef struct st_stack
*****************************************************************************/ *****************************************************************************/
#ifdef QSORT_EXTRA_CMP_ARGUMENT #ifdef QSORT_EXTRA_CMP_ARGUMENT
qsort_t qsort2(void *base_ptr, size_t count, size_t size, qsort2_cmp cmp, qsort_t my_qsort2(void *base_ptr, size_t count, size_t size, qsort2_cmp cmp,
void *cmp_argument) void *cmp_argument)
#else #else
qsort_t qsort(void *base_ptr, size_t count, size_t size, qsort_cmp cmp) qsort_t my_qsort(void *base_ptr, size_t count, size_t size, qsort_cmp cmp)
#endif #endif
{ {
char *low, *high, *pivot; char *low, *high, *pivot;

4
mysys/mf_sort.c
View File

@ -34,8 +34,8 @@ void my_string_ptr_sort(uchar *base, uint items, size_t size)
{ {
if (size && items) if (size && items)
{ {
qsort2(base,items, sizeof(uchar*), get_ptr_compare(size), my_qsort2(base,items, sizeof(uchar*), get_ptr_compare(size),
(void*) &size); (void*) &size);
} }
} }
} }

4
mysys/my_lib.c
View File

@ -180,7 +180,7 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
result->number_off_files= dir_entries_storage->elements; result->number_off_files= dir_entries_storage->elements;
if (!(MyFlags & MY_DONT_SORT)) if (!(MyFlags & MY_DONT_SORT))
qsort((void *) result->dir_entry, result->number_off_files, my_qsort((void *) result->dir_entry, result->number_off_files,
sizeof(FILEINFO), (qsort_cmp) comp_names); sizeof(FILEINFO), (qsort_cmp) comp_names);
DBUG_RETURN(result); DBUG_RETURN(result);
@ -491,7 +491,7 @@ MY_DIR *my_dir(const char *path, myf MyFlags)
result->number_off_files= dir_entries_storage->elements; result->number_off_files= dir_entries_storage->elements;
if (!(MyFlags & MY_DONT_SORT)) if (!(MyFlags & MY_DONT_SORT))
qsort((void *) result->dir_entry, result->number_off_files, my_qsort((void *) result->dir_entry, result->number_off_files,
sizeof(FILEINFO), (qsort_cmp) comp_names); sizeof(FILEINFO), (qsort_cmp) comp_names);
DBUG_PRINT("exit", ("found %d files", result->number_off_files)); DBUG_PRINT("exit", ("found %d files", result->number_off_files));
DBUG_RETURN(result); DBUG_RETURN(result);

2
mysys/queues.c
View File

@ -382,7 +382,7 @@ void queue_fix(QUEUE *queue)
make test_priority_queue make test_priority_queue
./test_priority_queue ./test_priority_queue
Written by Mikael Ronström, 2005 Written by Mikael Ronström, 2005
*/ */
static uint num_array[1025]; static uint num_array[1025];

2
sql/item_cmpfunc.cc
View File

@ -2831,7 +2831,7 @@ static inline int cmp_ulongs (ulonglong a_val, ulonglong b_val)
SYNOPSIS SYNOPSIS
cmp_longlong() cmp_longlong()
cmp_arg an argument passed to the calling function (qsort2) cmp_arg an argument passed to the calling function (my_qsort2)
a left argument a left argument
b right argument b right argument

2
sql/item_cmpfunc.h
View File

@ -738,7 +738,7 @@ public:
virtual uchar *get_value(Item *item)=0; virtual uchar *get_value(Item *item)=0;
void sort() void sort()
{ {
qsort2(base,used_count,size,compare,collation); my_qsort2(base,used_count,size,compare,collation);
} }
int find(Item *item); int find(Item *item);

8
sql/opt_range.cc
View File

@ -4465,8 +4465,8 @@ TRP_ROR_INTERSECT *get_best_ror_intersect(const PARAM *param, SEL_TREE *tree,
ROR_SCAN_INFO's. ROR_SCAN_INFO's.
Step 2: Get best ROR-intersection using an approximate algorithm. Step 2: Get best ROR-intersection using an approximate algorithm.
*/ */
qsort(tree->ror_scans, tree->n_ror_scans, sizeof(ROR_SCAN_INFO*), my_qsort(tree->ror_scans, tree->n_ror_scans, sizeof(ROR_SCAN_INFO*),
(qsort_cmp)cmp_ror_scan_info); (qsort_cmp)cmp_ror_scan_info);
DBUG_EXECUTE("info",print_ror_scans_arr(param->table, "ordered", DBUG_EXECUTE("info",print_ror_scans_arr(param->table, "ordered",
tree->ror_scans, tree->ror_scans,
tree->ror_scans_end);); tree->ror_scans_end););
@ -4658,8 +4658,8 @@ TRP_ROR_INTERSECT *get_best_covering_ror_intersect(PARAM *param,
bitmap_get_first(&(*scan)->covered_fields); bitmap_get_first(&(*scan)->covered_fields);
} }
qsort(ror_scan_mark, ror_scans_end-ror_scan_mark, sizeof(ROR_SCAN_INFO*), my_qsort(ror_scan_mark, ror_scans_end-ror_scan_mark, sizeof(ROR_SCAN_INFO*),
(qsort_cmp)cmp_ror_scan_info_covering); (qsort_cmp)cmp_ror_scan_info_covering);
DBUG_EXECUTE("info", print_ror_scans_arr(param->table, DBUG_EXECUTE("info", print_ror_scans_arr(param->table,
"remaining scans", "remaining scans",

3
sql/records.cc
View File

@ -565,7 +565,8 @@ static int rr_from_cache(READ_RECORD *info)
int3store(ref_position,(long) i); int3store(ref_position,(long) i);
ref_position+=3; ref_position+=3;
} }
qsort(info->read_positions,length,info->struct_length,(qsort_cmp) rr_cmp); my_qsort(info->read_positions, length, info->struct_length,
(qsort_cmp) rr_cmp);
position=info->read_positions; position=info->read_positions;
for (i=0 ; i < length ; i++) for (i=0 ; i < length ; i++)

20
sql/sql_acl.cc
View File

@ -364,8 +364,8 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
#endif #endif
VOID(push_dynamic(&acl_hosts,(uchar*) &host)); VOID(push_dynamic(&acl_hosts,(uchar*) &host));
} }
qsort((uchar*) dynamic_element(&acl_hosts,0,ACL_HOST*),acl_hosts.elements, my_qsort((uchar*) dynamic_element(&acl_hosts,0,ACL_HOST*),acl_hosts.elements,
sizeof(ACL_HOST),(qsort_cmp) acl_compare); sizeof(ACL_HOST),(qsort_cmp) acl_compare);
end_read_record(&read_record_info); end_read_record(&read_record_info);
freeze_size(&acl_hosts); freeze_size(&acl_hosts);
@ -552,8 +552,8 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
allow_all_hosts=1; // Anyone can connect allow_all_hosts=1; // Anyone can connect
} }
} }
qsort((uchar*) dynamic_element(&acl_users,0,ACL_USER*),acl_users.elements, my_qsort((uchar*) dynamic_element(&acl_users,0,ACL_USER*),acl_users.elements,
sizeof(ACL_USER),(qsort_cmp) acl_compare); sizeof(ACL_USER),(qsort_cmp) acl_compare);
end_read_record(&read_record_info); end_read_record(&read_record_info);
freeze_size(&acl_users); freeze_size(&acl_users);
@ -611,8 +611,8 @@ static my_bool acl_load(THD *thd, TABLE_LIST *tables)
#endif #endif
VOID(push_dynamic(&acl_dbs,(uchar*) &db)); VOID(push_dynamic(&acl_dbs,(uchar*) &db));
} }
qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements, my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
sizeof(ACL_DB),(qsort_cmp) acl_compare); sizeof(ACL_DB),(qsort_cmp) acl_compare);
end_read_record(&read_record_info); end_read_record(&read_record_info);
freeze_size(&acl_dbs); freeze_size(&acl_dbs);
init_check_host(); init_check_host();
@ -1242,8 +1242,8 @@ static void acl_insert_user(const char *user, const char *host,
if (!acl_user.host.hostname || if (!acl_user.host.hostname ||
(acl_user.host.hostname[0] == wild_many && !acl_user.host.hostname[1])) (acl_user.host.hostname[0] == wild_many && !acl_user.host.hostname[1]))
allow_all_hosts=1; // Anyone can connect /* purecov: tested */ allow_all_hosts=1; // Anyone can connect /* purecov: tested */
qsort((uchar*) dynamic_element(&acl_users,0,ACL_USER*),acl_users.elements, my_qsort((uchar*) dynamic_element(&acl_users,0,ACL_USER*),acl_users.elements,
sizeof(ACL_USER),(qsort_cmp) acl_compare); sizeof(ACL_USER),(qsort_cmp) acl_compare);
/* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */ /* Rebuild 'acl_check_hosts' since 'acl_users' has been modified */
rebuild_check_host(); rebuild_check_host();
@ -1305,8 +1305,8 @@ static void acl_insert_db(const char *user, const char *host, const char *db,
acl_db.access=privileges; acl_db.access=privileges;
acl_db.sort=get_sort(3,acl_db.host.hostname,acl_db.db,acl_db.user); acl_db.sort=get_sort(3,acl_db.host.hostname,acl_db.db,acl_db.user);
VOID(push_dynamic(&acl_dbs,(uchar*) &acl_db)); VOID(push_dynamic(&acl_dbs,(uchar*) &acl_db));
qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements, my_qsort((uchar*) dynamic_element(&acl_dbs,0,ACL_DB*),acl_dbs.elements,
sizeof(ACL_DB),(qsort_cmp) acl_compare); sizeof(ACL_DB),(qsort_cmp) acl_compare);
} }

2
sql/sql_array.h
View File

@ -62,7 +62,7 @@ public:
void sort(CMP_FUNC cmp_func) void sort(CMP_FUNC cmp_func)
{ {
qsort(array.buffer, array.elements, sizeof(Elem), (qsort_cmp)cmp_func); my_qsort(array.buffer, array.elements, sizeof(Elem), (qsort_cmp)cmp_func);
} }
}; };

2
sql/sql_help.cc
View File

@ -528,7 +528,7 @@ int send_variant_2_list(MEM_ROOT *mem_root, Protocol *protocol,
List_iterator<String> it(*names); List_iterator<String> it(*names);
for (pos= pointers; pos!=end; (*pos++= it++)); for (pos= pointers; pos!=end; (*pos++= it++));
qsort(pointers,names->elements,sizeof(String*),string_ptr_cmp); my_qsort(pointers,names->elements,sizeof(String*),string_ptr_cmp);
for (pos= pointers; pos!=end; pos++) for (pos= pointers; pos!=end; pos++)
{ {

18
sql/sql_select.cc
View File

@ -3706,7 +3706,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
{ {
KEYUSE key_end,*prev,*save_pos,*use; KEYUSE key_end,*prev,*save_pos,*use;
qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE), my_qsort(keyuse->buffer,keyuse->elements,sizeof(KEYUSE),
(qsort_cmp) sort_keyuse); (qsort_cmp) sort_keyuse);
bzero((char*) &key_end,sizeof(key_end)); /* Add for easy testing */ bzero((char*) &key_end,sizeof(key_end)); /* Add for easy testing */
@ -4475,8 +4475,9 @@ choose_plan(JOIN *join, table_map join_tables)
Apply heuristic: pre-sort all access plans with respect to the number of Apply heuristic: pre-sort all access plans with respect to the number of
records accessed. records accessed.
*/ */
qsort(join->best_ref + join->const_tables, join->tables - join->const_tables, my_qsort(join->best_ref + join->const_tables,
sizeof(JOIN_TAB*), straight_join?join_tab_cmp_straight:join_tab_cmp); join->tables - join->const_tables, sizeof(JOIN_TAB*),
straight_join ? join_tab_cmp_straight : join_tab_cmp);
if (straight_join) if (straight_join)
{ {
@ -4523,6 +4524,17 @@ choose_plan(JOIN *join, table_map join_tables)
ptr1 pointer to first JOIN_TAB object ptr1 pointer to first JOIN_TAB object
ptr2 pointer to second JOIN_TAB object ptr2 pointer to second JOIN_TAB object
NOTES
The order relation implemented by join_tab_cmp() is not transitive,
i.e. it is possible to choose such a, b and c that (a < b) && (b < c)
but (c < a). This implies that result of a sort using the relation
implemented by join_tab_cmp() depends on the order in which
elements are compared, i.e. the result is implementation-specific.
Example:
a: dependent = 0x0 table->map = 0x1 found_records = 3 ptr = 0x907e6b0
b: dependent = 0x0 table->map = 0x2 found_records = 3 ptr = 0x907e838
c: dependent = 0x6 table->map = 0x10 found_records = 2 ptr = 0x907ecd0
RETURN RETURN
1 if first is bigger 1 if first is bigger
-1 if second is bigger -1 if second is bigger

4
sql/sql_table.cc
View File

@ -2931,8 +2931,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
DBUG_RETURN(TRUE); DBUG_RETURN(TRUE);
} }
/* Sort keys in optimized order */ /* Sort keys in optimized order */
qsort((uchar*) *key_info_buffer, *key_count, sizeof(KEY), my_qsort((uchar*) *key_info_buffer, *key_count, sizeof(KEY),
(qsort_cmp) sort_keys); (qsort_cmp) sort_keys);
create_info->null_bits= null_fields; create_info->null_bits= null_fields;
DBUG_RETURN(FALSE); DBUG_RETURN(FALSE);

4
storage/csv/ha_tina.cc
View File

@ -1195,8 +1195,8 @@ int ha_tina::rnd_end()
The sort is needed when there were updates/deletes with random orders. The sort is needed when there were updates/deletes with random orders.
It sorts so that we move the firts blocks to the beginning. It sorts so that we move the firts blocks to the beginning.
*/ */
qsort(chain, (size_t)(chain_ptr - chain), sizeof(tina_set), my_qsort(chain, (size_t)(chain_ptr - chain), sizeof(tina_set),
(qsort_cmp)sort_set); (qsort_cmp)sort_set);
off_t write_begin= 0, write_end; off_t write_begin= 0, write_end;

4
storage/myisam/ft_boolean_search.c
View File

@ -576,8 +576,8 @@ FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, uchar *query,
ftb->list=(FTB_WORD **)alloc_root(&ftb->mem_root, ftb->list=(FTB_WORD **)alloc_root(&ftb->mem_root,
sizeof(FTB_WORD *)*ftb->queue.elements); sizeof(FTB_WORD *)*ftb->queue.elements);
memcpy(ftb->list, ftb->queue.root+1, sizeof(FTB_WORD *)*ftb->queue.elements); memcpy(ftb->list, ftb->queue.root+1, sizeof(FTB_WORD *)*ftb->queue.elements);
qsort2(ftb->list, ftb->queue.elements, sizeof(FTB_WORD *), my_qsort2(ftb->list, ftb->queue.elements, sizeof(FTB_WORD *),
(qsort2_cmp)FTB_WORD_cmp_list, ftb->charset); (qsort2_cmp)FTB_WORD_cmp_list, ftb->charset);
if (ftb->queue.elements<2) ftb->with_scan &= ~FTB_FLAG_TRUNC; if (ftb->queue.elements<2) ftb->with_scan &= ~FTB_FLAG_TRUNC;
ftb->state=READY; ftb->state=READY;
return ftb; return ftb;

3
storage/myisam/ft_nlq_search.c
View File

@ -294,7 +294,8 @@ FT_INFO *ft_init_nlq_search(MI_INFO *info, uint keynr, uchar *query,
&dptr, left_root_right); &dptr, left_root_right);
if (flags & FT_SORTED) if (flags & FT_SORTED)
qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), (qsort2_cmp)&FT_DOC_cmp, 0); my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), (qsort2_cmp)&FT_DOC_cmp,
0);
err: err:
delete_tree(&aio.dtree); delete_tree(&aio.dtree);

2
storage/myisam/myisampack.c
View File

@ -3148,7 +3148,7 @@ static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count)
cur_sort_p= sort_counts; cur_sort_p= sort_counts;
while (cur_count_p < end_count_p) while (cur_count_p < end_count_p)
*(cur_sort_p++)= cur_count_p++; *(cur_sort_p++)= cur_count_p++;
(void) qsort(sort_counts, 256, sizeof(my_off_t*), (qsort_cmp) fakecmp); (void) my_qsort(sort_counts, 256, sizeof(my_off_t*), (qsort_cmp) fakecmp);
/* /*
Assign faked counts. Assign faked counts.

12
storage/myisam/sort.c
View File

@ -650,8 +650,8 @@ static int NEAR_F write_keys(MI_SORT_PARAM *info, register uchar **sort_keys,
uint sort_length=info->key_length; uint sort_length=info->key_length;
DBUG_ENTER("write_keys"); DBUG_ENTER("write_keys");
qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp, my_qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp,
info); info);
if (!my_b_inited(tempfile) && if (!my_b_inited(tempfile) &&
open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST", open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
DISK_BUFFER_SIZE, info->sort_info->param->myf_rw)) DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
@ -693,8 +693,8 @@ static int NEAR_F write_keys_varlen(MI_SORT_PARAM *info,
int err; int err;
DBUG_ENTER("write_keys_varlen"); DBUG_ENTER("write_keys_varlen");
qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp, my_qsort2((uchar*) sort_keys,count,sizeof(uchar*),(qsort2_cmp) info->key_cmp,
info); info);
if (!my_b_inited(tempfile) && if (!my_b_inited(tempfile) &&
open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST", open_cached_file(tempfile, my_tmpdir(info->tmpdir), "ST",
DISK_BUFFER_SIZE, info->sort_info->param->myf_rw)) DISK_BUFFER_SIZE, info->sort_info->param->myf_rw))
@ -736,8 +736,8 @@ static int NEAR_F write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
{ {
DBUG_ENTER("write_index"); DBUG_ENTER("write_index");
qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*), my_qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*),
(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++))