mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-15 19:42:28 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

MDEV-34348: Consolidate cmp function declarations

Browse source 
Partial commit of the greater MDEV-34348 scope.
MDEV-34348: MariaDB is violating clang-16 -Wcast-function-type-strict

The functions queue_compare, qsort2_cmp, and qsort_cmp2
all had similar interfaces, and were used interchangable
and unsafely cast to one another.

This patch consolidates the functions all into the
qsort_cmp2 interface.

Reviewed By:
============
Marko Mäkelä <marko.makela@mariadb.com>
This commit is contained in:
Brandon Nesterenko 2024-10-26 08:17:03 -06:00
parent 3997d28f48
commit dbfee9fc2b
83 changed files with 678 additions and 524 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
client/mysqltest.cc
View file

@ -12077,8 +12077,10 @@ void replace_dynstr_append_uint(DYNAMIC_STRING *ds, uint val)
keep_header If header should not be sorted keep_header If header should not be sorted
*/ */
static int comp_lines(const char **a, const char **b) static int comp_lines(const void *a_, const void *b_)
{ {
auto a= static_cast<const char *const *>(a_);
auto b= static_cast<const char *const *>(b_);
return (strcmp(*a,*b)); return (strcmp(*a,*b));
} }

1
include/CMakeLists.txt
View file

@ -42,6 +42,7 @@ SET(HEADERS
my_dbug.h my_dbug.h
m_string.h m_string.h
my_sys.h my_sys.h
my_cmp.h
my_xml.h my_xml.h
mysql_embed.h mysql_embed.h
my_decimal_limits.h my_decimal_limits.h

25
include/my_cmp.h Normal file
View file

@ -0,0 +1,25 @@
/* Copyright (c) 2024, MariaDB Corporation.
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; version 2 of the License.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#pragma once
#ifdef __cplusplus
extern "C" {
#endif
typedef int (*qsort_cmp)(const void *, const void *);
typedef int (*qsort_cmp2)(void *param, const void *a, const void *b);
#ifdef __cplusplus
}
#endif

5
include/my_global.h
View file

@ -528,10 +528,7 @@ typedef int pbool; /* Mixed prototypes can't take char */
typedef int pshort; /* Mixed prototypes can't take short int */ typedef int pshort; /* Mixed prototypes can't take short int */
typedef double pfloat; /* Mixed prototypes can't take float */ typedef double pfloat; /* Mixed prototypes can't take float */
#endif #endif
C_MODE_START #include <my_cmp.h>
typedef int (*qsort_cmp)(const void *,const void *);
typedef int (*qsort_cmp2)(void*, const void *,const void *);
C_MODE_END
#define qsort_t RETQSORTTYPE /* Broken GCC can't handle typedef !!!! */ #define qsort_t RETQSORTTYPE /* Broken GCC can't handle typedef !!!! */
#ifdef HAVE_SYS_SOCKET_H #ifdef HAVE_SYS_SOCKET_H
#include <sys/socket.h> #include <sys/socket.h>

7
include/my_sys.h
View file

@ -29,6 +29,7 @@ C_MODE_START
#include <stdarg.h> #include <stdarg.h>
#include <typelib.h> #include <typelib.h>
#include <my_alloca.h> #include <my_alloca.h>
#include <my_cmp.h>
#include <mysql/plugin.h> #include <mysql/plugin.h>
#include <mysql/service_my_print_error.h> #include <mysql/service_my_print_error.h>
@ -462,8 +463,6 @@ typedef struct st_io_cache /* Used when caching files */
size_t alloced_buffer; size_t alloced_buffer;
} IO_CACHE; } IO_CACHE;
typedef int (*qsort2_cmp)(const void *, const void *, const void *);
typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...) typedef void (*my_error_reporter)(enum loglevel level, const char *format, ...)
ATTRIBUTE_FORMAT_FPTR(printf, 2, 3); ATTRIBUTE_FORMAT_FPTR(printf, 2, 3);
@ -763,8 +762,8 @@ extern void radixsort_for_str_ptr(uchar* base[], uint number_of_elements,
extern qsort_t my_qsort(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,
qsort_cmp cmp); qsort_cmp cmp);
extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size, extern qsort_t my_qsort2(void *base_ptr, size_t total_elems, size_t size,
qsort2_cmp cmp, void *cmp_argument); qsort_cmp2 cmp, void *cmp_argument);
extern qsort2_cmp get_ptr_compare(size_t); extern qsort_cmp2 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);
extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize, extern int init_io_cache(IO_CACHE *info,File file,size_t cachesize,

2
include/myisam.h
View file

@ -373,7 +373,7 @@ typedef struct st_mi_sort_param
my_bool fix_datafile, master; my_bool fix_datafile, master;
my_bool calc_checksum; /* calculate table checksum */ my_bool calc_checksum; /* calculate table checksum */
int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *); int (*key_cmp)(void *, const void *, const void *);
int (*key_read)(struct st_mi_sort_param *,void *); int (*key_read)(struct st_mi_sort_param *,void *);
int (*key_write)(struct st_mi_sort_param *, const void *); int (*key_write)(struct st_mi_sort_param *, const void *);
void (*lock_in_memory)(HA_CHECK *); void (*lock_in_memory)(HA_CHECK *);

9
include/queues.h
View file

@ -31,6 +31,8 @@
#ifndef _queues_h #ifndef _queues_h
#define _queues_h #define _queues_h
#include <my_cmp.h>
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -44,7 +46,7 @@ typedef struct st_queue {
uint offset_to_queue_pos; /* If we want to store position in element */ uint offset_to_queue_pos; /* If we want to store position in element */
uint auto_extent; uint auto_extent;
int max_at_top; /* Normally 1, set to -1 if queue_top gives max */ int max_at_top; /* Normally 1, set to -1 if queue_top gives max */
int (*compare)(void *, uchar *,uchar *); qsort_cmp2 compare;
} QUEUE; } QUEUE;
#define queue_first_element(queue) 1 #define queue_first_element(queue) 1
@ -58,14 +60,13 @@ typedef struct st_queue {
#define queue_set_max_at_top(queue, set_arg) \ #define queue_set_max_at_top(queue, set_arg) \
(queue)->max_at_top= set_arg ? -1 : 1 (queue)->max_at_top= set_arg ? -1 : 1
#define queue_remove_top(queue_arg) queue_remove((queue_arg), queue_first_element(queue_arg)) #define queue_remove_top(queue_arg) queue_remove((queue_arg), queue_first_element(queue_arg))
typedef int (*queue_compare)(void *,uchar *, uchar *);
int init_queue(QUEUE *queue,uint max_elements,uint offset_to_key, int init_queue(QUEUE *queue,uint max_elements,uint offset_to_key,
my_bool max_at_top, queue_compare compare, my_bool max_at_top, qsort_cmp2 compare,
void *first_cmp_arg, uint offset_to_queue_pos, void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent); uint auto_extent);
int reinit_queue(QUEUE *queue,uint max_elements,uint offset_to_key, int reinit_queue(QUEUE *queue,uint max_elements,uint offset_to_key,
my_bool max_at_top, queue_compare compare, my_bool max_at_top, qsort_cmp2 compare,
void *first_cmp_arg, uint offset_to_queue_pos, void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent); uint auto_extent);
int resize_queue(QUEUE *queue, uint max_elements); int resize_queue(QUEUE *queue, uint max_elements);

4
mysys/mf_keycache.c
View file

@ -3753,8 +3753,10 @@ static void free_block(SIMPLE_KEY_CACHE_CB *keycache, BLOCK_LINK *block)
} }
static int cmp_sec_link(BLOCK_LINK **a, BLOCK_LINK **b) static int cmp_sec_link(const void *_a, const void *_b)
{ {
BLOCK_LINK *const *a= _a;
BLOCK_LINK *const *b= _b;
return (((*a)->hash_link->diskpos < (*b)->hash_link->diskpos) ? -1 : return (((*a)->hash_link->diskpos < (*b)->hash_link->diskpos) ? -1 :
((*a)->hash_link->diskpos > (*b)->hash_link->diskpos) ? 1 : 0); ((*a)->hash_link->diskpos > (*b)->hash_link->diskpos) ? 1 : 0);
} }

4
mysys/mf_qsort.c
View file

@ -84,7 +84,7 @@ typedef struct st_stack
/**************************************************************************** /****************************************************************************
** 'standard' quicksort with the following extensions: ** 'standard' quicksort with the following extensions:
** **
** Can be compiled with the qsort2_cmp compare function ** Can be compiled with the qsort_cmp2 compare function
** Store ranges on stack to avoid recursion ** Store ranges on stack to avoid recursion
** Use insert sort on small ranges ** Use insert sort on small ranges
** Optimize for sorting of pointers (used often by MySQL) ** Optimize for sorting of pointers (used often by MySQL)
@ -92,7 +92,7 @@ typedef struct st_stack
*****************************************************************************/ *****************************************************************************/
#ifdef QSORT_EXTRA_CMP_ARGUMENT #ifdef QSORT_EXTRA_CMP_ARGUMENT
qsort_t my_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, qsort_cmp2 cmp,
void *cmp_argument) void *cmp_argument)
#else #else
qsort_t my_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)

6
mysys/my_lib.c
View file

@ -57,7 +57,7 @@
#define NAMES_START_SIZE 32768 #define NAMES_START_SIZE 32768
static int comp_names(struct fileinfo *a,struct fileinfo *b); static int comp_names(const void *a, const void *b);
typedef struct { typedef struct {
MY_DIR dir; MY_DIR dir;
@ -83,8 +83,10 @@ void my_dirend(MY_DIR *dir)
/* Compare in sort of filenames */ /* Compare in sort of filenames */
static int comp_names(struct fileinfo *a, struct fileinfo *b) static int comp_names(const void *a_, const void *b_)
{ {
const struct fileinfo *a= a_;
const struct fileinfo *b= b_;
return (strcmp(a->name,b->name)); return (strcmp(a->name,b->name));
} /* comp_names */ } /* comp_names */

4
mysys/my_likely.c
View file

@ -55,8 +55,10 @@ void init_my_likely()
pthread_mutex_init(&likely_mutex, MY_MUTEX_INIT_FAST); pthread_mutex_init(&likely_mutex, MY_MUTEX_INIT_FAST);
} }
static int likely_cmp(LIKELY_ENTRY **a, LIKELY_ENTRY **b) static int likely_cmp(const void *a_, const void *b_)
{ {
const LIKELY_ENTRY *const *a= a_;
const LIKELY_ENTRY *const *b= b_;
int cmp; int cmp;
if ((cmp= strcmp((*a)->key, (*b)->key))) if ((cmp= strcmp((*a)->key, (*b)->key)))
return cmp; return cmp;

79
mysys/ptr_cmp.c
View file

@ -44,40 +44,43 @@
#include <string.h> #include <string.h>
static int native_compare(size_t *length, unsigned char **a, unsigned char **b) static int native_compare(void *length_, const void *a_, const void *b_)
{ {
size_t *length= length_;
const unsigned char *const *a= a_;
const unsigned char *const *b= b_;
return memcmp(*a, *b, *length); return memcmp(*a, *b, *length);
} }
qsort2_cmp get_ptr_compare (size_t size __attribute__((unused))) qsort_cmp2 get_ptr_compare (size_t size __attribute__((unused)))
{ {
return (qsort2_cmp) native_compare; return native_compare;
} }
#else /* USE_NATIVE_MEMCMP */ #else /* USE_NATIVE_MEMCMP */
static int ptr_compare(size_t *compare_length, uchar **a, uchar **b); static int ptr_compare(void *compare_length, const void *a, const void *b);
static int ptr_compare_0(size_t *compare_length, uchar **a, uchar **b); static int ptr_compare_0(void *compare_length, const void *a, const void *b);
static int ptr_compare_1(size_t *compare_length, uchar **a, uchar **b); static int ptr_compare_1(void *compare_length, const void *a, const void *b);
static int ptr_compare_2(size_t *compare_length, uchar **a, uchar **b); static int ptr_compare_2(void *compare_length, const void *a, const void *b);
static int ptr_compare_3(size_t *compare_length, uchar **a, uchar **b); static int ptr_compare_3(void *compare_length, const void *a, const void *b);
static int degenerate_compare_func(size_t *compare_length, uchar **a, uchar **b) static int degenerate_compare_func(void *compare_length, const void *a, const void *b)
{ {
DBUG_ASSERT(*compare_length == 0); DBUG_ASSERT(*((size_t *) compare_length) == 0);
return 0; return 0;
} }
qsort2_cmp get_ptr_compare (size_t size) qsort_cmp2 get_ptr_compare (size_t size)
{ {
if (size == 0) if (size == 0)
return (qsort2_cmp) degenerate_compare_func; return degenerate_compare_func;
if (size < 4) if (size < 4)
return (qsort2_cmp) ptr_compare; return ptr_compare;
switch (size & 3) { switch (size & 3) {
case 0: return (qsort2_cmp) ptr_compare_0; case 0: return ptr_compare_0;
case 1: return (qsort2_cmp) ptr_compare_1; case 1: return ptr_compare_1;
case 2: return (qsort2_cmp) ptr_compare_2; case 2: return ptr_compare_2;
case 3: return (qsort2_cmp) ptr_compare_3; case 3: return ptr_compare_3;
} }
return 0; /* Impossible */ return 0; /* Impossible */
} }
@ -88,13 +91,13 @@ qsort2_cmp get_ptr_compare (size_t size)
#define cmp(N) if (first[N] != last[N]) return (int) first[N] - (int) last[N] #define cmp(N) if (first[N] != last[N]) return (int) first[N] - (int) last[N]
static int ptr_compare(size_t *compare_length, uchar **a, uchar **b) static int ptr_compare(void *compare_length, const void *a, const void *b)
{ {
size_t length= *compare_length; size_t length= *((size_t *) compare_length);
uchar *first,*last; const uchar *first= *((const uchar *const *) a);
const uchar *last= *((const uchar *const *) b);
DBUG_ASSERT(length > 0); DBUG_ASSERT(length > 0);
first= *a; last= *b;
while (--length) while (--length)
{ {
if (*first++ != *last++) if (*first++ != *last++)
@ -104,12 +107,11 @@ static int ptr_compare(size_t *compare_length, uchar **a, uchar **b)
} }
static int ptr_compare_0(size_t *compare_length,uchar **a, uchar **b) static int ptr_compare_0(void *compare_length, const void *a, const void *b)
{ {
size_t length= *compare_length; size_t length= *((size_t *) compare_length);
uchar *first,*last; const uchar *first= *((const uchar *const *) a);
const uchar *last= *((const uchar *const *) b);
first= *a; last= *b;
loop: loop:
cmp(0); cmp(0);
cmp(1); cmp(1);
@ -125,12 +127,13 @@ static int ptr_compare_0(size_t *compare_length,uchar **a, uchar **b)
} }
static int ptr_compare_1(size_t *compare_length,uchar **a, uchar **b) static int ptr_compare_1(void *compare_length, const void *a, const void *b)
{ {
size_t length= *compare_length-1;
uchar *first,*last;
first= *a+1; last= *b+1; size_t length= *((size_t *) compare_length) - 1;
const uchar *first= *((const uchar *const *) a) + 1;
const uchar *last= *((const uchar *const *) b) + 1;
cmp(-1); cmp(-1);
loop: loop:
cmp(0); cmp(0);
@ -146,12 +149,12 @@ static int ptr_compare_1(size_t *compare_length,uchar **a, uchar **b)
return (0); return (0);
} }
static int ptr_compare_2(size_t *compare_length,uchar **a, uchar **b) static int ptr_compare_2(void *compare_length, const void *a, const void *b)
{ {
size_t length= *compare_length-2; size_t length= *((size_t *) compare_length) - 2;
uchar *first,*last; const uchar *first= *((const uchar *const *) a) + 2;
const uchar *last= *((const uchar *const *) b) + 2;
first= *a +2 ; last= *b +2;
cmp(-2); cmp(-2);
cmp(-1); cmp(-1);
loop: loop:
@ -168,12 +171,12 @@ static int ptr_compare_2(size_t *compare_length,uchar **a, uchar **b)
return (0); return (0);
} }
static int ptr_compare_3(size_t *compare_length,uchar **a, uchar **b) static int ptr_compare_3(void *compare_length, const void *a, const void *b)
{ {
size_t length= *compare_length-3; size_t length= *((size_t *) compare_length) - 3;
uchar *first,*last; const uchar *first= *((const uchar *const *) a) + 3;
const uchar *last= *((const uchar *const *) b) + 3;
first= *a +3 ; last= *b +3;
cmp(-3); cmp(-3);
cmp(-2); cmp(-2);
cmp(-1); cmp(-1);

4
mysys/queues.c
View file

@ -70,7 +70,7 @@
*/ */
int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key, int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *), my_bool max_at_top, qsort_cmp2 compare,
void *first_cmp_arg, uint offset_to_queue_pos, void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent) uint auto_extent)
{ {
@ -109,7 +109,7 @@ int init_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
*/ */
int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key, int reinit_queue(QUEUE *queue, uint max_elements, uint offset_to_key,
my_bool max_at_top, int (*compare) (void *, uchar *, uchar *), my_bool max_at_top, qsort_cmp2 compare,
void *first_cmp_arg, uint offset_to_queue_pos, void *first_cmp_arg, uint offset_to_queue_pos,
uint auto_extent) uint auto_extent)
{ {

7
mysys/thr_alarm.c
View file

@ -77,10 +77,11 @@ static void *alarm_handler(void *arg);
static sig_handler thread_alarm(int sig __attribute__((unused))); static sig_handler thread_alarm(int sig __attribute__((unused)));
static int compare_ulong(void *not_used __attribute__((unused)), static int compare_ulong(void *not_used __attribute__((unused)),
uchar *a_ptr,uchar* b_ptr) const void *a_ptr, const void *b_ptr)
{ {
ulong a=*((ulong*) a_ptr),b= *((ulong*) b_ptr); const ulong *ap= a_ptr;
return (a < b) ? -1 : (a == b) ? 0 : 1; const ulong *bp= b_ptr;
return (*ap < *bp) ? -1 : (*ap == *bp) ? 0 : 1;
} }
void init_thr_alarm(uint max_alarms) void init_thr_alarm(uint max_alarms)

7
mysys/thr_timer.c
View file

@ -46,10 +46,11 @@ static void *timer_handler(void *arg __attribute__((unused)));
*/ */
static int compare_timespec(void *not_used __attribute__((unused)), static int compare_timespec(void *not_used __attribute__((unused)),
uchar *a_ptr, uchar *b_ptr) const void *a_ptr, const void *b_ptr)
{ {
return cmp_timespec((*(struct timespec*) a_ptr), const struct timespec *ap= a_ptr;
(*(struct timespec*) b_ptr)); const struct timespec *bp= b_ptr;
return cmp_timespec((*ap), (*bp));
} }

10
plugin/type_inet/sql_type_inet.cc
View file

@ -594,9 +594,9 @@ public:
Inet6_null tmp(arg); Inet6_null tmp(arg);
return m_null_value || tmp.is_null() ? UNKNOWN : m_native.cmp(tmp) != 0; return m_null_value || tmp.is_null() ? UNKNOWN : m_native.cmp(tmp) != 0;
} }
int compare(cmp_item *ci) override int compare(const cmp_item *ci) const override
{ {
cmp_item_inet6 *tmp= static_cast<cmp_item_inet6*>(ci); const cmp_item_inet6 *tmp= static_cast<const cmp_item_inet6*>(ci);
DBUG_ASSERT(!m_null_value); DBUG_ASSERT(!m_null_value);
DBUG_ASSERT(!tmp->m_null_value); DBUG_ASSERT(!tmp->m_null_value);
return m_native.cmp(tmp->m_native); return m_native.cmp(tmp->m_native);
@ -1293,13 +1293,15 @@ public:
class in_inet6 :public in_vector class in_inet6 :public in_vector
{ {
Inet6 m_value; Inet6 m_value;
static int cmp_inet6(void *cmp_arg, Inet6 *a, Inet6 *b) static int cmp_inet6(void *, const void *a_, const void *b_)
{ {
const Inet6 *a= static_cast<const Inet6*>(a_);
const Inet6 *b= static_cast<const Inet6*>(b_);
return a->cmp(*b); return a->cmp(*b);
} }
public: public:
in_inet6(THD *thd, uint elements) in_inet6(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(Inet6), (qsort2_cmp) cmp_inet6, 0), :in_vector(thd, elements, sizeof(Inet6), cmp_inet6, 0),
m_value(Inet6_zero()) m_value(Inet6_zero())
{ } { }
const Type_handler *type_handler() const override const Type_handler *type_handler() const override

20
sql/bounded_queue.h
View file

@ -62,16 +62,6 @@ public:
Element_type *from, Element_type *from,
bool packing_keys); bool packing_keys);
/**
Function for comparing two keys.
@param n Pointer to number of bytes to compare.
@param a First key.
@param b Second key.
@retval -1, 0, or 1 depending on whether the left argument is
less than, equal to, or greater than the right argument.
*/
typedef int (*compare_function)(size_t *n, Key_type **a, Key_type **b);
/** /**
Initialize the queue. Initialize the queue.
@ -81,8 +71,6 @@ public:
pop() will return the smallest key in the result set. pop() will return the smallest key in the result set.
true: We keep the n smallest elements. true: We keep the n smallest elements.
pop() will return the largest key in the result set. pop() will return the largest key in the result set.
@param compare Compare function for elements, takes 3 arguments.
If NULL, we use get_ptr_compare(compare_length).
@param compare_length Length of the data (i.e. the keys) used for sorting. @param compare_length Length of the data (i.e. the keys) used for sorting.
@param keymaker Function which generates keys for elements. @param keymaker Function which generates keys for elements.
@param sort_param Sort parameters. @param sort_param Sort parameters.
@ -93,7 +81,7 @@ public:
We do *not* take ownership of any of the input pointer arguments. We do *not* take ownership of any of the input pointer arguments.
*/ */
int init(ha_rows max_elements, bool max_at_top, int init(ha_rows max_elements, bool max_at_top,
compare_function compare, size_t compare_length, size_t compare_length,
keymaker_function keymaker, Sort_param *sort_param, keymaker_function keymaker, Sort_param *sort_param,
Key_type **sort_keys); Key_type **sort_keys);
@ -148,7 +136,6 @@ private:
template<typename Element_type, typename Key_type> template<typename Element_type, typename Key_type>
int Bounded_queue<Element_type, Key_type>::init(ha_rows max_elements, int Bounded_queue<Element_type, Key_type>::init(ha_rows max_elements,
bool max_at_top, bool max_at_top,
compare_function compare,
size_t compare_length, size_t compare_length,
keymaker_function keymaker, keymaker_function keymaker,
Sort_param *sort_param, Sort_param *sort_param,
@ -163,13 +150,10 @@ int Bounded_queue<Element_type, Key_type>::init(ha_rows max_elements,
// init_queue() takes an uint, and also does (max_elements + 1) // init_queue() takes an uint, and also does (max_elements + 1)
if (max_elements >= (UINT_MAX - 1)) if (max_elements >= (UINT_MAX - 1))
return 1; return 1;
if (compare == NULL)
compare=
reinterpret_cast<compare_function>(get_ptr_compare(compare_length));
// We allocate space for one extra element, for replace when queue is full. // We allocate space for one extra element, for replace when queue is full.
return init_queue(&m_queue, (uint) max_elements + 1, return init_queue(&m_queue, (uint) max_elements + 1,
0, max_at_top, 0, max_at_top,
reinterpret_cast<queue_compare>(compare), get_ptr_compare(compare_length),
&m_compare_length, 0, 0); &m_compare_length, 0, 0);
} }

6
sql/event_queue.cc
View file

@ -67,10 +67,10 @@
extern "C" int event_queue_element_compare_q(void *, uchar *, uchar *); extern "C" int event_queue_element_compare_q(void *, uchar *, uchar *);
int event_queue_element_compare_q(void *vptr, uchar* a, uchar *b) int event_queue_element_compare_q(void *, const void *a, const void *b)
{ {
Event_queue_element *left = (Event_queue_element *)a; auto left= static_cast<const Event_queue_element *>(a);
Event_queue_element *right = (Event_queue_element *)b; auto right= static_cast<const Event_queue_element *>(b);
my_time_t lhs = left->execute_at; my_time_t lhs = left->execute_at;
my_time_t rhs = right->execute_at; my_time_t rhs = right->execute_at;

31
sql/filesort.cc
View file

@ -283,7 +283,6 @@ SORT_INFO *filesort(THD *thd, TABLE *table, Filesort *filesort,
sort->init_record_pointers(); sort->init_record_pointers();
if (pq.init(param.max_rows, if (pq.init(param.max_rows,
true, // max_at_top true, // max_at_top
NULL, // compare_function
compare_length, compare_length,
&make_sortkey, &param, sort->get_sort_keys())) &make_sortkey, &param, sort->get_sort_keys()))
{ {
@ -1820,7 +1819,7 @@ bool merge_buffers(Sort_param *param, IO_CACHE *from_file,
uchar *strpos; uchar *strpos;
Merge_chunk *buffpek; Merge_chunk *buffpek;
QUEUE queue; QUEUE queue;
qsort2_cmp cmp; qsort_cmp2 cmp;
void *first_cmp_arg; void *first_cmp_arg;
element_count dupl_count= 0; element_count dupl_count= 0;
uchar *src; uchar *src;
@ -1864,9 +1863,9 @@ bool merge_buffers(Sort_param *param, IO_CACHE *from_file,
cmp= param->get_compare_function(); cmp= param->get_compare_function();
first_cmp_arg= param->get_compare_argument(&sort_length); first_cmp_arg= param->get_compare_argument(&sort_length);
} }
if (unlikely(init_queue(&queue, (uint) (Tb-Fb)+1, if (unlikely(init_queue(&queue, (uint) (Tb - Fb) + 1,
offsetof(Merge_chunk,m_current_key), 0, offsetof(Merge_chunk, m_current_key), 0, cmp,
(queue_compare) cmp, first_cmp_arg, 0, 0))) first_cmp_arg, 0, 0)))
DBUG_RETURN(1); /* purecov: inspected */ DBUG_RETURN(1); /* purecov: inspected */
const size_t chunk_sz = (sort_buffer.size()/((uint) (Tb-Fb) +1)); const size_t chunk_sz = (sort_buffer.size()/((uint) (Tb-Fb) +1));
for (buffpek= Fb ; buffpek <= Tb ; buffpek++) for (buffpek= Fb ; buffpek <= Tb ; buffpek++)
@ -2786,9 +2785,9 @@ void SORT_FIELD_ATTR::set_length_and_original_length(THD *thd, uint length_arg)
Compare function used for packing sort keys Compare function used for packing sort keys
*/ */
qsort2_cmp get_packed_keys_compare_ptr() qsort_cmp2 get_packed_keys_compare_ptr()
{ {
return (qsort2_cmp) compare_packed_sort_keys; return compare_packed_sort_keys;
} }
@ -2802,8 +2801,8 @@ qsort2_cmp get_packed_keys_compare_ptr()
suffix_bytes are used only for binary columns. suffix_bytes are used only for binary columns.
*/ */
int SORT_FIELD_ATTR::compare_packed_varstrings(uchar *a, size_t *a_len, int SORT_FIELD_ATTR::compare_packed_varstrings(const uchar *a, size_t *a_len,
uchar *b, size_t *b_len) const uchar *b, size_t *b_len)
{ {
int retval; int retval;
size_t a_length, b_length; size_t a_length, b_length;
@ -2862,8 +2861,8 @@ int SORT_FIELD_ATTR::compare_packed_varstrings(uchar *a, size_t *a_len,
packed-value format. packed-value format.
*/ */
int SORT_FIELD_ATTR::compare_packed_fixed_size_vals(uchar *a, size_t *a_len, int SORT_FIELD_ATTR::compare_packed_fixed_size_vals(const uchar *a, size_t *a_len,
uchar *b, size_t *b_len) const uchar *b, size_t *b_len)
{ {
if (maybe_null) if (maybe_null)
{ {
@ -2908,15 +2907,15 @@ int SORT_FIELD_ATTR::compare_packed_fixed_size_vals(uchar *a, size_t *a_len,
*/ */
int compare_packed_sort_keys(void *sort_param, int compare_packed_sort_keys(void *sort_param, const void *a_ptr,
unsigned char **a_ptr, unsigned char **b_ptr) const void *b_ptr)
{ {
int retval= 0; int retval= 0;
size_t a_len, b_len; size_t a_len, b_len;
Sort_param *param= (Sort_param*)sort_param; Sort_param *param= static_cast<Sort_param *>(sort_param);
Sort_keys *sort_keys= param->sort_keys; Sort_keys *sort_keys= param->sort_keys;
uchar *a= *a_ptr; auto a= *(static_cast<const uchar *const *>(a_ptr));
uchar *b= *b_ptr; auto b= *(static_cast<const uchar *const *>(b_ptr));
a+= Sort_keys::size_of_length_field; a+= Sort_keys::size_of_length_field;
b+= Sort_keys::size_of_length_field; b+= Sort_keys::size_of_length_field;

6
sql/filesort_utils.h
View file

@ -268,8 +268,8 @@ private:
longlong m_idx; longlong m_idx;
}; };
int compare_packed_sort_keys(void *sort_keys, unsigned char **a, int compare_packed_sort_keys(void *sort_param, const void *a_ptr,
unsigned char **b); const void *b_ptr);
qsort2_cmp get_packed_keys_compare_ptr(); qsort_cmp2 get_packed_keys_compare_ptr();
#endif // FILESORT_UTILS_INCLUDED #endif // FILESORT_UTILS_INCLUDED

31
sql/ha_partition.cc
View file

@ -5515,7 +5515,7 @@ bool ha_partition::init_record_priority_queue()
m_start_key.key= (const uchar*)ptr; m_start_key.key= (const uchar*)ptr;
/* Initialize priority queue, initialized to reading forward. */ /* Initialize priority queue, initialized to reading forward. */
int (*cmp_func)(void *, uchar *, uchar *); int (*cmp_func)(void *, const void *, const void *);
void *cmp_arg= (void*) this; void *cmp_arg= (void*) this;
if (!m_using_extended_keys && !(table_flags() & HA_SLOW_CMP_REF)) if (!m_using_extended_keys && !(table_flags() & HA_SLOW_CMP_REF))
cmp_func= cmp_key_rowid_part_id; cmp_func= cmp_key_rowid_part_id;
@ -5763,8 +5763,10 @@ int ha_partition::index_read_map(uchar *buf, const uchar *key,
/* Compare two part_no partition numbers */ /* Compare two part_no partition numbers */
static int cmp_part_ids(uchar *ref1, uchar *ref2) static int cmp_part_ids(const void *ref1_, const void *ref2_)
{ {
auto ref1= static_cast<const uchar *>(ref1_);
auto ref2= static_cast<const uchar *>(ref2_);
uint32 diff2= uint2korr(ref2); uint32 diff2= uint2korr(ref2);
uint32 diff1= uint2korr(ref1); uint32 diff1= uint2korr(ref1);
if (diff2 > diff1) if (diff2 > diff1)
@ -5780,9 +5782,12 @@ static int cmp_part_ids(uchar *ref1, uchar *ref2)
Provide ordering by (key_value, part_no). Provide ordering by (key_value, part_no).
*/ */
extern "C" int cmp_key_part_id(void *ptr, uchar *ref1, uchar *ref2) extern "C" int cmp_key_part_id(void *ptr, const void *ref1_, const void *ref2_)
{ {
ha_partition *file= (ha_partition*)ptr; const ha_partition *file= static_cast<const ha_partition *>(ptr);
const uchar *ref1= static_cast<const uchar *>(ref1_);
const uchar *ref2= static_cast<const uchar *>(ref2_);
if (int res= key_rec_cmp(file->m_curr_key_info, if (int res= key_rec_cmp(file->m_curr_key_info,
ref1 + PARTITION_BYTES_IN_POS, ref1 + PARTITION_BYTES_IN_POS,
ref2 + PARTITION_BYTES_IN_POS)) ref2 + PARTITION_BYTES_IN_POS))
@ -5794,9 +5799,13 @@ extern "C" int cmp_key_part_id(void *ptr, uchar *ref1, uchar *ref2)
@brief @brief
Provide ordering by (key_value, underying_table_rowid, part_no). Provide ordering by (key_value, underying_table_rowid, part_no).
*/ */
extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2) extern "C" int cmp_key_rowid_part_id(void *ptr, const void *ref1_,
const void *ref2_)
{ {
ha_partition *file= (ha_partition*)ptr; const ha_partition *file= static_cast<const ha_partition *>(ptr);
const uchar *ref1= static_cast<const uchar *>(ref1_);
const uchar *ref2= static_cast<const uchar *>(ref2_);
int res; int res;
if ((res= key_rec_cmp(file->m_curr_key_info, ref1 + PARTITION_BYTES_IN_POS, if ((res= key_rec_cmp(file->m_curr_key_info, ref1 + PARTITION_BYTES_IN_POS,
@ -8348,10 +8357,12 @@ int ha_partition::handle_ordered_prev(uchar *buf)
Helper function for sorting according to number of rows in descending order. Helper function for sorting according to number of rows in descending order.
*/ */
int ha_partition::compare_number_of_records(ha_partition *me, int ha_partition::compare_number_of_records(void *me_, const void *a_,
const uint32 *a, const void *b_)
const uint32 *b)
{ {
const ha_partition *me= static_cast<const ha_partition *>(me_);
const uint32 *a= static_cast<const uint32 *>(a_);
const uint32 *b= static_cast<const uint32 *>(b_);
handler **file= me->m_file; handler **file= me->m_file;
/* Note: sorting in descending order! */ /* Note: sorting in descending order! */
if (file[*a]->stats.records > file[*b]->stats.records) if (file[*a]->stats.records > file[*b]->stats.records)
@ -8651,7 +8662,7 @@ int ha_partition::info(uint flag)
my_qsort2((void*) m_part_ids_sorted_by_num_of_records, my_qsort2((void*) m_part_ids_sorted_by_num_of_records,
m_tot_parts, m_tot_parts,
sizeof(uint32), sizeof(uint32),
(qsort2_cmp) compare_number_of_records, compare_number_of_records,
this); this);
file= m_file[handler_instance]; file= m_file[handler_instance];

13
sql/ha_partition.h
View file

@ -277,8 +277,8 @@ typedef struct st_partition_part_key_multi_range_hld
} PARTITION_PART_KEY_MULTI_RANGE_HLD; } PARTITION_PART_KEY_MULTI_RANGE_HLD;
extern "C" int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2); extern "C" int cmp_key_part_id(void *key_p, const void *ref1, const void *ref2);
extern "C" int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2); extern "C" int cmp_key_rowid_part_id(void *ptr, const void *ref1, const void *ref2);
class ha_partition :public handler class ha_partition :public handler
{ {
@ -446,9 +446,7 @@ private:
/** Sorted array of partition ids in descending order of number of rows. */ /** Sorted array of partition ids in descending order of number of rows. */
uint32 *m_part_ids_sorted_by_num_of_records; uint32 *m_part_ids_sorted_by_num_of_records;
/* Compare function for my_qsort2, for reversed order. */ /* Compare function for my_qsort2, for reversed order. */
static int compare_number_of_records(ha_partition *me, static int compare_number_of_records(void *me, const void *a, const void *b);
const uint32 *a,
const uint32 *b);
/** keep track of partitions to call ha_reset */ /** keep track of partitions to call ha_reset */
MY_BITMAP m_partitions_to_reset; MY_BITMAP m_partitions_to_reset;
/** partitions that returned HA_ERR_KEY_NOT_FOUND. */ /** partitions that returned HA_ERR_KEY_NOT_FOUND. */
@ -1635,8 +1633,9 @@ public:
int notify_tabledef_changed(LEX_CSTRING *db, LEX_CSTRING *table, int notify_tabledef_changed(LEX_CSTRING *db, LEX_CSTRING *table,
LEX_CUSTRING *frm, LEX_CUSTRING *version); LEX_CUSTRING *frm, LEX_CUSTRING *version);
friend int cmp_key_rowid_part_id(void *ptr, uchar *ref1, uchar *ref2); friend int cmp_key_rowid_part_id(void *ptr, const void *ref1,
friend int cmp_key_part_id(void *key_p, uchar *ref1, uchar *ref2); const void *ref2);
friend int cmp_key_part_id(void *key_p, const void *ref1, const void *ref2);
bool can_convert_nocopy(const Field &field, bool can_convert_nocopy(const Field &field,
const Column_definition &new_field) const override; const Column_definition &new_field) const override;

8
sql/handler.cc
View file

@ -6116,15 +6116,19 @@ static int cmp_file_names(const void *a, const void *b)
return cs->strnncoll(aa, strlen(aa), bb, strlen(bb)); return cs->strnncoll(aa, strlen(aa), bb, strlen(bb));
} }
static int cmp_table_names(LEX_CSTRING * const *a, LEX_CSTRING * const *b) static int cmp_table_names(const void *a_, const void *b_)
{ {
auto a= static_cast<const LEX_CSTRING *const *>(a_);
auto b= static_cast<const LEX_CSTRING *const *>(b_);
return my_charset_bin.strnncoll((*a)->str, (*a)->length, return my_charset_bin.strnncoll((*a)->str, (*a)->length,
(*b)->str, (*b)->length); (*b)->str, (*b)->length);
} }
#ifndef DBUG_OFF #ifndef DBUG_OFF
static int cmp_table_names_desc(LEX_CSTRING * const *a, LEX_CSTRING * const *b) static int cmp_table_names_desc(const void *a_, const void *b_)
{ {
auto a= static_cast<const LEX_CSTRING *const *>(a_);
auto b= static_cast<const LEX_CSTRING *const *>(b_);
return -cmp_table_names(a, b); return -cmp_table_names(a, b);
} }
#endif #endif

60
sql/item_cmpfunc.cc
View file

@ -3650,10 +3650,10 @@ static inline int cmp_ulongs (ulonglong a_val, ulonglong b_val)
0 left argument is equal to the right argument. 0 left argument is equal to the right argument.
1 left argument is greater than the right argument. 1 left argument is greater than the right argument.
*/ */
int cmp_longlong(void *cmp_arg, int cmp_longlong(void *, const void *a_, const void *b_)
in_longlong::packed_longlong *a,
in_longlong::packed_longlong *b)
{ {
auto a= static_cast<const in_longlong::packed_longlong *>(a_);
auto b= static_cast<const in_longlong::packed_longlong *>(b_);
if (a->unsigned_flag != b->unsigned_flag) if (a->unsigned_flag != b->unsigned_flag)
{ {
/* /*
@ -3675,19 +3675,26 @@ int cmp_longlong(void *cmp_arg,
return cmp_longs(a->val, b->val); return cmp_longs(a->val, b->val);
} }
static int cmp_double(void *cmp_arg, double *a,double *b) static int cmp_double(void *, const void *a_, const void *b_)
{ {
const double *a= static_cast<const double *>(a_);
const double *b= static_cast<const double *>(b_);
return *a < *b ? -1 : *a == *b ? 0 : 1; return *a < *b ? -1 : *a == *b ? 0 : 1;
} }
static int cmp_row(void *cmp_arg, cmp_item_row *a, cmp_item_row *b) static int cmp_row(void *, const void *a_, const void *b_)
{ {
const cmp_item_row *a= static_cast<const cmp_item_row *>(a_);
const cmp_item_row *b= static_cast<const cmp_item_row *>(b_);
return a->compare(b); return a->compare(b);
} }
static int cmp_decimal(void *cmp_arg, my_decimal *a, my_decimal *b) static int cmp_decimal(void *, const void *a_, const void *b_)
{ {
my_decimal *a= const_cast<my_decimal *>(static_cast<const my_decimal *>(a_));
my_decimal *b= const_cast<my_decimal *>(static_cast<const my_decimal *>(b_));
/* /*
We need call of fixing buffer pointer, because fast sort just copy We need call of fixing buffer pointer, because fast sort just copy
decimal buffers in memory and pointers left pointing on old buffer place decimal buffers in memory and pointers left pointing on old buffer place
@ -3710,17 +3717,19 @@ bool in_vector::find(Item *item)
{ {
uint mid=(start+end+1)/2; uint mid=(start+end+1)/2;
int res; int res;
if ((res=(*compare)(collation, base+mid*size, result)) == 0) if ((res= (*compare)(const_cast<charset_info_st *>(collation),
base + mid * size, result)) == 0)
return true; return true;
if (res < 0) if (res < 0)
start=mid; start=mid;
else else
end=mid-1; end=mid-1;
} }
return ((*compare)(collation, base+start*size, result) == 0); return ((*compare)(const_cast<charset_info_st *>(collation),
base + start * size, result) == 0);
} }
in_string::in_string(THD *thd, uint elements, qsort2_cmp cmp_func, in_string::in_string(THD *thd, uint elements, qsort_cmp2 cmp_func,
CHARSET_INFO *cs) CHARSET_INFO *cs)
:in_vector(thd, elements, sizeof(String), cmp_func, cs), :in_vector(thd, elements, sizeof(String), cmp_func, cs),
tmp(buff, sizeof(buff), &my_charset_bin) tmp(buff, sizeof(buff), &my_charset_bin)
@ -3775,7 +3784,7 @@ in_row::in_row(THD *thd, uint elements, Item * item)
{ {
base= (char*) new (thd->mem_root) cmp_item_row[count= elements]; base= (char*) new (thd->mem_root) cmp_item_row[count= elements];
size= sizeof(cmp_item_row); size= sizeof(cmp_item_row);
compare= (qsort2_cmp) cmp_row; compare= cmp_row;
/* /*
We need to reset these as otherwise we will call sort() with We need to reset these as otherwise we will call sort() with
uninitialized (even if not used) elements uninitialized (even if not used) elements
@ -3807,8 +3816,7 @@ bool in_row::set(uint pos, Item *item)
} }
in_longlong::in_longlong(THD *thd, uint elements) in_longlong::in_longlong(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(packed_longlong), : in_vector(thd, elements, sizeof(packed_longlong), cmp_longlong, 0)
(qsort2_cmp) cmp_longlong, 0)
{} {}
bool in_longlong::set(uint pos, Item *item) bool in_longlong::set(uint pos, Item *item)
@ -3839,16 +3847,16 @@ Item *in_longlong::create_item(THD *thd)
} }
static int cmp_timestamp(void *cmp_arg, static int cmp_timestamp(void *, const void *a_, const void *b_)
Timestamp_or_zero_datetime *a,
Timestamp_or_zero_datetime *b)
{ {
auto a= static_cast<const Timestamp_or_zero_datetime *>(a_);
auto b= static_cast<const Timestamp_or_zero_datetime *>(b_);
return a->cmp(*b); return a->cmp(*b);
} }
in_timestamp::in_timestamp(THD *thd, uint elements) in_timestamp::in_timestamp(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(Value), (qsort2_cmp) cmp_timestamp, 0) :in_vector(thd, elements, sizeof(Value), cmp_timestamp, 0)
{} {}
@ -3932,7 +3940,7 @@ Item *in_temporal::create_item(THD *thd)
in_double::in_double(THD *thd, uint elements) in_double::in_double(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(double), (qsort2_cmp) cmp_double, 0) :in_vector(thd, elements, sizeof(double), cmp_double, 0)
{} {}
bool in_double::set(uint pos, Item *item) bool in_double::set(uint pos, Item *item)
@ -3956,7 +3964,7 @@ Item *in_double::create_item(THD *thd)
in_decimal::in_decimal(THD *thd, uint elements) in_decimal::in_decimal(THD *thd, uint elements)
:in_vector(thd, elements, sizeof(my_decimal), (qsort2_cmp) cmp_decimal, 0) :in_vector(thd, elements, sizeof(my_decimal), cmp_decimal, 0)
{} {}
@ -4201,9 +4209,9 @@ int cmp_item_row::cmp(Item *arg)
} }
int cmp_item_row::compare(cmp_item *c) int cmp_item_row::compare(const cmp_item *c) const
{ {
cmp_item_row *l_cmp= (cmp_item_row *) c; auto l_cmp= static_cast<const cmp_item_row *>(c);
for (uint i=0; i < n; i++) for (uint i=0; i < n; i++)
{ {
int res; int res;
@ -4239,9 +4247,9 @@ int cmp_item_decimal::cmp(Item *arg)
} }
int cmp_item_decimal::compare(cmp_item *arg) int cmp_item_decimal::compare(const cmp_item *arg) const
{ {
cmp_item_decimal *l_cmp= (cmp_item_decimal*) arg; auto l_cmp= static_cast<const cmp_item_decimal *>(arg);
return my_decimal_cmp(&value, &l_cmp->value); return my_decimal_cmp(&value, &l_cmp->value);
} }
@ -4282,9 +4290,9 @@ int cmp_item_time::cmp(Item *arg)
} }
int cmp_item_temporal::compare(cmp_item *ci) int cmp_item_temporal::compare(const cmp_item *ci) const
{ {
cmp_item_temporal *l_cmp= (cmp_item_temporal *)ci; auto l_cmp= static_cast<const cmp_item_temporal *>(ci);
return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1); return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
} }
@ -4330,9 +4338,9 @@ int cmp_item_timestamp::cmp(Item *arg)
} }
int cmp_item_timestamp::compare(cmp_item *arg) int cmp_item_timestamp::compare(const cmp_item *arg) const
{ {
cmp_item_timestamp *tmp= static_cast<cmp_item_timestamp*>(arg); auto tmp= static_cast<const cmp_item_timestamp *>(arg);
return type_handler_timestamp2.cmp_native(m_native, tmp->m_native); return type_handler_timestamp2.cmp_native(m_native, tmp->m_native);
} }

31
sql/item_cmpfunc.h
View file

@ -1365,12 +1365,12 @@ class in_vector :public Sql_alloc
public: public:
char *base; char *base;
uint size; uint size;
qsort2_cmp compare; qsort_cmp2 compare;
CHARSET_INFO *collation; CHARSET_INFO *collation;
uint count; uint count;
uint used_count; uint used_count;
in_vector() = default; in_vector() = default;
in_vector(THD *thd, uint elements, uint element_length, qsort2_cmp cmp_func, in_vector(THD *thd, uint elements, uint element_length, qsort_cmp2 cmp_func,
CHARSET_INFO *cmp_coll) CHARSET_INFO *cmp_coll)
:base((char*) thd_calloc(thd, elements * element_length)), :base((char*) thd_calloc(thd, elements * element_length)),
size(element_length), compare(cmp_func), collation(cmp_coll), size(element_length), compare(cmp_func), collation(cmp_coll),
@ -1414,7 +1414,8 @@ public:
/* Compare values number pos1 and pos2 for equality */ /* Compare values number pos1 and pos2 for equality */
bool compare_elems(uint pos1, uint pos2) bool compare_elems(uint pos1, uint pos2)
{ {
return MY_TEST(compare(collation, base + pos1 * size, base + pos2 * size)); return MY_TEST(compare(const_cast<charset_info_st *>(collation),
base + pos1 * size, base + pos2 * size));
} }
virtual const Type_handler *type_handler() const= 0; virtual const Type_handler *type_handler() const= 0;
}; };
@ -1436,7 +1437,7 @@ class in_string :public in_vector
} }
}; };
public: public:
in_string(THD *thd, uint elements, qsort2_cmp cmp_func, CHARSET_INFO *cs); in_string(THD *thd, uint elements, qsort_cmp2 cmp_func, CHARSET_INFO *cs);
~in_string(); ~in_string();
bool set(uint pos, Item *item) override; bool set(uint pos, Item *item) override;
uchar *get_value(Item *item) override; uchar *get_value(Item *item) override;
@ -1476,7 +1477,7 @@ public:
} }
const Type_handler *type_handler() const override { return &type_handler_slonglong; } const Type_handler *type_handler() const override { return &type_handler_slonglong; }
friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b); friend int cmp_longlong(void *cmp_arg, const void *a, const void *b);
}; };
@ -1510,7 +1511,7 @@ public:
Item_datetime *dt= static_cast<Item_datetime*>(item); Item_datetime *dt= static_cast<Item_datetime*>(item);
dt->set(val->val, type_handler()->mysql_timestamp_type()); dt->set(val->val, type_handler()->mysql_timestamp_type());
} }
friend int cmp_longlong(void *cmp_arg, packed_longlong *a,packed_longlong *b); friend int cmp_longlong(void *cmp_arg, const void *a, const void *b);
}; };
@ -1590,7 +1591,7 @@ public:
virtual int cmp(Item *item)= 0; virtual int cmp(Item *item)= 0;
virtual int cmp_not_null(const Value *value)= 0; virtual int cmp_not_null(const Value *value)= 0;
// for optimized IN with row // for optimized IN with row
virtual int compare(cmp_item *item)= 0; virtual int compare(const cmp_item *item) const = 0;
virtual cmp_item *make_same()= 0; virtual cmp_item *make_same()= 0;
/* /*
Store a scalar or a ROW value into "this". Store a scalar or a ROW value into "this".
@ -1668,7 +1669,7 @@ public:
else else
return TRUE; return TRUE;
} }
int compare(cmp_item *ci) override int compare(const cmp_item *ci) const override
{ {
cmp_item_string *l_cmp= (cmp_item_string *) ci; cmp_item_string *l_cmp= (cmp_item_string *) ci;
return sortcmp(value_res, l_cmp->value_res, cmp_charset); return sortcmp(value_res, l_cmp->value_res, cmp_charset);
@ -1702,7 +1703,7 @@ public:
const bool rc= value != arg->val_int(); const bool rc= value != arg->val_int();
return (m_null_value || arg->null_value) ? UNKNOWN : rc; return (m_null_value || arg->null_value) ? UNKNOWN : rc;
} }
int compare(cmp_item *ci) override int compare(const cmp_item *ci) const override
{ {
cmp_item_int *l_cmp= (cmp_item_int *)ci; cmp_item_int *l_cmp= (cmp_item_int *)ci;
return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1); return (value < l_cmp->value) ? -1 : ((value == l_cmp->value) ? 0 : 1);
@ -1719,7 +1720,7 @@ protected:
longlong value; longlong value;
public: public:
cmp_item_temporal() = default; cmp_item_temporal() = default;
int compare(cmp_item *ci) override; int compare(const cmp_item *ci) const override;
}; };
@ -1765,7 +1766,7 @@ public:
void store_value(Item *item) override; void store_value(Item *item) override;
int cmp_not_null(const Value *val) override; int cmp_not_null(const Value *val) override;
int cmp(Item *arg) override; int cmp(Item *arg) override;
int compare(cmp_item *ci) override; int compare(const cmp_item *ci) const override;
cmp_item *make_same() override; cmp_item *make_same() override;
}; };
@ -1791,7 +1792,7 @@ public:
const bool rc= value != arg->val_real(); const bool rc= value != arg->val_real();
return (m_null_value || arg->null_value) ? UNKNOWN : rc; return (m_null_value || arg->null_value) ? UNKNOWN : rc;
} }
int compare(cmp_item *ci) override int compare(const cmp_item *ci) const override
{ {
cmp_item_real *l_cmp= (cmp_item_real *) ci; cmp_item_real *l_cmp= (cmp_item_real *) ci;
return (value < l_cmp->value)? -1 : ((value == l_cmp->value) ? 0 : 1); return (value < l_cmp->value)? -1 : ((value == l_cmp->value) ? 0 : 1);
@ -1808,7 +1809,7 @@ public:
void store_value(Item *item) override; void store_value(Item *item) override;
int cmp(Item *arg) override; int cmp(Item *arg) override;
int cmp_not_null(const Value *val) override; int cmp_not_null(const Value *val) override;
int compare(cmp_item *c) override; int compare(const cmp_item *c) const override;
cmp_item *make_same() override; cmp_item *make_same() override;
}; };
@ -1841,7 +1842,7 @@ public:
DBUG_ASSERT(false); DBUG_ASSERT(false);
return TRUE; return TRUE;
} }
int compare(cmp_item *ci) override int compare(const cmp_item *ci) const override
{ {
cmp_item_string *l_cmp= (cmp_item_string *) ci; cmp_item_string *l_cmp= (cmp_item_string *) ci;
return sortcmp(value_res, l_cmp->value_res, cmp_charset); return sortcmp(value_res, l_cmp->value_res, cmp_charset);
@ -2557,7 +2558,7 @@ public:
DBUG_ASSERT(false); DBUG_ASSERT(false);
return TRUE; return TRUE;
} }
int compare(cmp_item *arg) override; int compare(const cmp_item *arg) const override;
cmp_item *make_same() override; cmp_item *make_same() override;
bool store_value_by_template(THD *thd, cmp_item *tmpl, Item *) override; bool store_value_by_template(THD *thd, cmp_item *tmpl, Item *) override;
friend class Item_func_in; friend class Item_func_in;

35
sql/item_subselect.cc
View file

@ -6039,7 +6039,7 @@ bool Ordered_key::alloc_keys_buffers()
*/ */
int int
Ordered_key::cmp_keys_by_row_data(ha_rows a, ha_rows b) Ordered_key::cmp_keys_by_row_data(const ha_rows a, const ha_rows b) const
{ {
uchar *rowid_a, *rowid_b; uchar *rowid_a, *rowid_b;
int error; int error;
@ -6081,10 +6081,12 @@ Ordered_key::cmp_keys_by_row_data(ha_rows a, ha_rows b)
} }
int int Ordered_key::cmp_keys_by_row_data_and_rownum(void *key_, const void *a_,
Ordered_key::cmp_keys_by_row_data_and_rownum(Ordered_key *key, const void *b_)
rownum_t* a, rownum_t* b)
{ {
Ordered_key *key= static_cast<Ordered_key *>(key_);
const rownum_t *a= static_cast<const rownum_t *>(a_);
const rownum_t *b= static_cast<const rownum_t *>(b_);
/* The result of comparing the two keys according to their row data. */ /* The result of comparing the two keys according to their row data. */
int cmp_row_res= key->cmp_keys_by_row_data(*a, *b); int cmp_row_res= key->cmp_keys_by_row_data(*a, *b);
if (cmp_row_res) if (cmp_row_res)
@ -6098,7 +6100,7 @@ bool Ordered_key::sort_keys()
if (tbl->file->ha_rnd_init_with_error(0)) if (tbl->file->ha_rnd_init_with_error(0))
return TRUE; return TRUE;
my_qsort2(key_buff, (size_t) key_buff_elements, sizeof(rownum_t), my_qsort2(key_buff, (size_t) key_buff_elements, sizeof(rownum_t),
(qsort2_cmp) &cmp_keys_by_row_data_and_rownum, (void*) this); &cmp_keys_by_row_data_and_rownum, (void *) this);
/* Invalidate the current row position. */ /* Invalidate the current row position. */
cur_key_idx= HA_POS_ERROR; cur_key_idx= HA_POS_ERROR;
tbl->file->ha_rnd_end(); tbl->file->ha_rnd_end();
@ -6114,7 +6116,7 @@ bool Ordered_key::sort_keys()
@retval 0 if only NULLs @retval 0 if only NULLs
*/ */
double Ordered_key::null_selectivity() inline double Ordered_key::null_selectivity() const
{ {
/* We should not be processing empty tables. */ /* We should not be processing empty tables. */
DBUG_ASSERT(tbl->file->stats.records); DBUG_ASSERT(tbl->file->stats.records);
@ -6246,7 +6248,7 @@ bool Ordered_key::next_same()
} }
void Ordered_key::print(String *str) void Ordered_key::print(String *str) const
{ {
uint i; uint i;
str->append("{idx="); str->append("{idx=");
@ -6605,10 +6607,11 @@ void subselect_rowid_merge_engine::cleanup()
@retval -1 if k1 is more selective than k2 @retval -1 if k1 is more selective than k2
*/ */
int int subselect_rowid_merge_engine::cmp_keys_by_null_selectivity(const void *k1_,
subselect_rowid_merge_engine::cmp_keys_by_null_selectivity(Ordered_key **k1, const void *k2_)
Ordered_key **k2)
{ {
auto k1= static_cast<const Ordered_key *const *>(k1_);
auto k2= static_cast<const Ordered_key *const *>(k2_);
double k1_sel= (*k1)->null_selectivity(); double k1_sel= (*k1)->null_selectivity();
double k2_sel= (*k2)->null_selectivity(); double k2_sel= (*k2)->null_selectivity();
if (k1_sel < k2_sel) if (k1_sel < k2_sel)
@ -6622,12 +6625,14 @@ subselect_rowid_merge_engine::cmp_keys_by_null_selectivity(Ordered_key **k1,
/* /*
*/ */
int int subselect_rowid_merge_engine::cmp_keys_by_cur_rownum(void *,
subselect_rowid_merge_engine::cmp_keys_by_cur_rownum(void *arg, const void *k1_,
uchar *k1, uchar *k2) const void *k2_)
{ {
rownum_t r1= ((Ordered_key*) k1)->current(); auto k1= static_cast<const Ordered_key *>(k1_);
rownum_t r2= ((Ordered_key*) k2)->current(); auto k2= static_cast<const Ordered_key *>(k2_);
rownum_t r1= k1->current();
rownum_t r2= k2->current();
return (r1 < r2) ? -1 : (r1 > r2) ? 1 : 0; return (r1 < r2) ? -1 : (r1 > r2) ? 1 : 0;
} }

34
sql/item_subselect.h
View file

@ -1296,9 +1296,9 @@ protected:
Quick sort comparison function that compares two rows of the same table Quick sort comparison function that compares two rows of the same table
indentfied with their row numbers. indentfied with their row numbers.
*/ */
int cmp_keys_by_row_data(rownum_t a, rownum_t b); int cmp_keys_by_row_data(const rownum_t a, const rownum_t b) const;
static int cmp_keys_by_row_data_and_rownum(Ordered_key *key, static int cmp_keys_by_row_data_and_rownum(void *key, const void *a,
rownum_t* a, rownum_t* b); const void *b);
int cmp_key_with_search_key(rownum_t row_num); int cmp_key_with_search_key(rownum_t row_num);
@ -1314,23 +1314,23 @@ public:
/* Initialize a single-column index. */ /* Initialize a single-column index. */
bool init(int col_idx); bool init(int col_idx);
uint get_column_count() { return key_column_count; } uint get_column_count() const { return key_column_count; }
uint get_keyid() { return keyid; } uint get_keyid() const { return keyid; }
Field *get_field(uint i) Field *get_field(uint i) const
{ {
DBUG_ASSERT(i < key_column_count); DBUG_ASSERT(i < key_column_count);
return key_columns[i]->field; return key_columns[i]->field;
} }
rownum_t get_min_null_row() { return min_null_row; } rownum_t get_min_null_row() const { return min_null_row; }
rownum_t get_max_null_row() { return max_null_row; } rownum_t get_max_null_row() const { return max_null_row; }
MY_BITMAP * get_null_key() { return &null_key; } MY_BITMAP * get_null_key() { return &null_key; }
ha_rows get_null_count() { return null_count; } ha_rows get_null_count() const { return null_count; }
ha_rows get_key_buff_elements() { return key_buff_elements; } ha_rows get_key_buff_elements() const { return key_buff_elements; }
/* /*
Get the search key element that corresponds to the i-th key part of this Get the search key element that corresponds to the i-th key part of this
index. index.
*/ */
Item *get_search_key(uint i) Item *get_search_key(uint i) const
{ {
return search_key->element_index(key_columns[i]->field->field_index); return search_key->element_index(key_columns[i]->field->field_index);
} }
@ -1343,7 +1343,7 @@ public:
} }
bool sort_keys(); bool sort_keys();
double null_selectivity(); inline double null_selectivity() const;
/* /*
Position the current element at the first row that matches the key. Position the current element at the first row that matches the key.
@ -1371,7 +1371,7 @@ public:
return FALSE; return FALSE;
}; };
/* Return the current index element. */ /* Return the current index element. */
rownum_t current() rownum_t current() const
{ {
DBUG_ASSERT(key_buff_elements && cur_key_idx < key_buff_elements); DBUG_ASSERT(key_buff_elements && cur_key_idx < key_buff_elements);
return key_buff[cur_key_idx]; return key_buff[cur_key_idx];
@ -1381,7 +1381,7 @@ public:
{ {
bitmap_set_bit(&null_key, (uint)row_num); bitmap_set_bit(&null_key, (uint)row_num);
} }
bool is_null(rownum_t row_num) bool is_null(rownum_t row_num) const
{ {
/* /*
Indexes consisting of only NULLs do not have a bitmap buffer at all. Indexes consisting of only NULLs do not have a bitmap buffer at all.
@ -1397,7 +1397,7 @@ public:
return FALSE; return FALSE;
return bitmap_is_set(&null_key, (uint)row_num); return bitmap_is_set(&null_key, (uint)row_num);
} }
void print(String *str); void print(String *str) const;
}; };
@ -1515,12 +1515,12 @@ protected:
Comparison function to compare keys in order of decreasing bitmap Comparison function to compare keys in order of decreasing bitmap
selectivity. selectivity.
*/ */
static int cmp_keys_by_null_selectivity(Ordered_key **k1, Ordered_key **k2); static int cmp_keys_by_null_selectivity(const void *k1, const void *k2);
/* /*
Comparison function used by the priority queue pq, the 'smaller' key Comparison function used by the priority queue pq, the 'smaller' key
is the one with the smaller current row number. is the one with the smaller current row number.
*/ */
static int cmp_keys_by_cur_rownum(void *arg, uchar *k1, uchar *k2); static int cmp_keys_by_cur_rownum(void *, const void *k1, const void *k2);
bool test_null_row(rownum_t row_num); bool test_null_row(rownum_t row_num);
bool exists_complementing_null_row(MY_BITMAP *keys_to_complement); bool exists_complementing_null_row(MY_BITMAP *keys_to_complement);

50
sql/item_sum.cc
View file

@ -654,10 +654,11 @@ bool Item_sum::check_vcol_func_processor(void *arg)
@retval > 0 if key1 > key2 @retval > 0 if key1 > key2
*/ */
int simple_str_key_cmp(void* arg, uchar* key1, uchar* key2) int simple_str_key_cmp(void *arg, const void *key1, const void *key2)
{ {
Field *f= (Field*) arg; Field *f= static_cast<Field *>(arg);
return f->cmp(key1, key2); return f->cmp(static_cast<const uchar *>(key1),
static_cast<const uchar *>(key2));
} }
@ -687,9 +688,12 @@ C_MODE_END
@retval >0 if key1 > key2 @retval >0 if key1 > key2
*/ */
int Aggregator_distinct::composite_key_cmp(void* arg, uchar* key1, uchar* key2) int Aggregator_distinct::composite_key_cmp(void *arg, const void *key1_,
const void *key2_)
{ {
Aggregator_distinct *aggr= (Aggregator_distinct *) arg; const uchar *key1= static_cast<const uchar *>(key1_);
const uchar *key2= static_cast<const uchar *>(key2_);
Aggregator_distinct *aggr= static_cast<Aggregator_distinct *>(arg);
Field **field = aggr->table->field; Field **field = aggr->table->field;
Field **field_end= field + aggr->table->s->fields; Field **field_end= field + aggr->table->s->fields;
uint32 *lengths=aggr->field_lengths; uint32 *lengths=aggr->field_lengths;
@ -706,7 +710,6 @@ int Aggregator_distinct::composite_key_cmp(void* arg, uchar* key1, uchar* key2)
return 0; return 0;
} }
/***************************************************************************/ /***************************************************************************/
C_MODE_START C_MODE_START
@ -715,7 +718,7 @@ C_MODE_START
int simple_raw_key_cmp(void* arg, const void* key1, const void* key2) int simple_raw_key_cmp(void* arg, const void* key1, const void* key2)
{ {
return memcmp(key1, key2, *(uint *) arg); return memcmp(key1, key2, *(static_cast<uint *>(arg)));
} }
@ -837,7 +840,7 @@ bool Aggregator_distinct::setup(THD *thd)
if (all_binary) if (all_binary)
{ {
cmp_arg= (void*) &tree_key_length; cmp_arg= (void*) &tree_key_length;
compare_key= (qsort_cmp2) simple_raw_key_cmp; compare_key= simple_raw_key_cmp;
} }
else else
{ {
@ -849,14 +852,14 @@ bool Aggregator_distinct::setup(THD *thd)
compare method that can take advantage of not having to worry compare method that can take advantage of not having to worry
about other fields. about other fields.
*/ */
compare_key= (qsort_cmp2) simple_str_key_cmp; compare_key= simple_str_key_cmp;
cmp_arg= (void*) table->field[0]; cmp_arg= (void*) table->field[0];
/* tree_key_length has been set already */ /* tree_key_length has been set already */
} }
else else
{ {
uint32 *length; uint32 *length;
compare_key= (qsort_cmp2) composite_key_cmp; compare_key= composite_key_cmp;
cmp_arg= (void*) this; cmp_arg= (void*) this;
field_lengths= (uint32*) thd->alloc(table->s->fields * sizeof(uint32)); field_lengths= (uint32*) thd->alloc(table->s->fields * sizeof(uint32));
for (tree_key_length= 0, length= field_lengths, field= table->field; for (tree_key_length= 0, length= field_lengths, field= table->field;
@ -3559,11 +3562,10 @@ String *Item_sum_udf_str::val_str(String *str)
@retval 1 : key1 > key2 @retval 1 : key1 > key2
*/ */
extern "C" extern "C" int group_concat_key_cmp_with_distinct(void *arg, const void *key1,
int group_concat_key_cmp_with_distinct(void* arg, const void* key1, const void *key2)
const void* key2)
{ {
Item_func_group_concat *item_func= (Item_func_group_concat*)arg; auto item_func= static_cast<const Item_func_group_concat *>(arg);
for (uint i= 0; i < item_func->arg_count_field; i++) for (uint i= 0; i < item_func->arg_count_field; i++)
{ {
@ -3602,11 +3604,11 @@ int group_concat_key_cmp_with_distinct(void* arg, const void* key1,
Used for JSON_ARRAYAGG function Used for JSON_ARRAYAGG function
*/ */
int group_concat_key_cmp_with_distinct_with_nulls(void* arg, int group_concat_key_cmp_with_distinct_with_nulls(void *arg,
const void* key1_arg, const void *key1_arg,
const void* key2_arg) const void *key2_arg)
{ {
Item_func_group_concat *item_func= (Item_func_group_concat*)arg; auto item_func= static_cast<Item_func_group_concat *>(arg);
uchar *key1= (uchar*)key1_arg + item_func->table->s->null_bytes; uchar *key1= (uchar*)key1_arg + item_func->table->s->null_bytes;
uchar *key2= (uchar*)key2_arg + item_func->table->s->null_bytes; uchar *key2= (uchar*)key2_arg + item_func->table->s->null_bytes;
@ -3655,11 +3657,10 @@ int group_concat_key_cmp_with_distinct_with_nulls(void* arg,
function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... ) function of sort for syntax: GROUP_CONCAT(expr,... ORDER BY col,... )
*/ */
extern "C" extern "C" int group_concat_key_cmp_with_order(void *arg, const void *key1,
int group_concat_key_cmp_with_order(void* arg, const void* key1, const void *key2)
const void* key2)
{ {
Item_func_group_concat* grp_item= (Item_func_group_concat*) arg; auto grp_item= static_cast<Item_func_group_concat *>(arg);
ORDER **order_item, **end; ORDER **order_item, **end;
for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order; for (order_item= grp_item->order, end=order_item+ grp_item->arg_count_order;
@ -3715,10 +3716,11 @@ int group_concat_key_cmp_with_order(void* arg, const void* key1,
Used for JSON_ARRAYAGG function Used for JSON_ARRAYAGG function
*/ */
int group_concat_key_cmp_with_order_with_nulls(void *arg, const void *key1_arg, int group_concat_key_cmp_with_order_with_nulls(void *arg,
const void *key1_arg,
const void *key2_arg) const void *key2_arg)
{ {
Item_func_group_concat* grp_item= (Item_func_group_concat*) arg; auto grp_item= static_cast<const Item_func_group_concat *>(arg);
ORDER **order_item, **end; ORDER **order_item, **end;
uchar *key1= (uchar*)key1_arg + grp_item->table->s->null_bytes; uchar *key1= (uchar*)key1_arg + grp_item->table->s->null_bytes;

31
sql/item_sum.h
View file

@ -714,7 +714,7 @@ public:
bool unique_walk_function(void *element); bool unique_walk_function(void *element);
bool unique_walk_function_for_count(void *element); bool unique_walk_function_for_count(void *element);
static int composite_key_cmp(void* arg, uchar* key1, uchar* key2); static int composite_key_cmp(void *arg, const void *key1, const void *key2);
}; };
@ -1872,12 +1872,12 @@ public:
#endif /* HAVE_DLOPEN */ #endif /* HAVE_DLOPEN */
C_MODE_START C_MODE_START
int group_concat_key_cmp_with_distinct(void* arg, const void* key1, int group_concat_key_cmp_with_distinct(void *arg, const void *key1,
const void* key2); const void *key2);
int group_concat_key_cmp_with_distinct_with_nulls(void* arg, const void* key1, int group_concat_key_cmp_with_distinct_with_nulls(void *arg, const void *key1,
const void* key2); const void *key2);
int group_concat_key_cmp_with_order(void* arg, const void* key1, int group_concat_key_cmp_with_order(void *arg, const void *key1,
const void* key2); const void *key2);
int group_concat_key_cmp_with_order_with_nulls(void *arg, const void *key1, int group_concat_key_cmp_with_order_with_nulls(void *arg, const void *key1,
const void *key2); const void *key2);
int dump_leaf_key(void* key_arg, int dump_leaf_key(void* key_arg,
@ -1940,15 +1940,16 @@ protected:
*/ */
bool add(bool exclude_nulls); bool add(bool exclude_nulls);
friend int group_concat_key_cmp_with_distinct(void* arg, const void* key1, friend int group_concat_key_cmp_with_distinct(void *arg, const void *key1,
const void* key2); const void *key2);
friend int group_concat_key_cmp_with_distinct_with_nulls(void* arg, friend int group_concat_key_cmp_with_distinct_with_nulls(void *arg,
const void* key1, const void *key1,
const void* key2); const void *key2);
friend int group_concat_key_cmp_with_order(void* arg, const void* key1, friend int group_concat_key_cmp_with_order(void *arg, const void *key1,
const void* key2); const void *key2);
friend int group_concat_key_cmp_with_order_with_nulls(void *arg, friend int group_concat_key_cmp_with_order_with_nulls(void *arg,
const void *key1, const void *key2); const void *key1,
const void *key2);
friend int dump_leaf_key(void* key_arg, friend int dump_leaf_key(void* key_arg,
element_count count __attribute__((unused)), element_count count __attribute__((unused)),
void* item_arg); void* item_arg);

11
sql/key.cc
View file

@ -551,10 +551,10 @@ int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length)
@retval +1 first_rec is greater than second_rec @retval +1 first_rec is greater than second_rec
*/ */
int key_rec_cmp(void *key_p, uchar *first_rec, uchar *second_rec) int key_rec_cmp(const KEY *const *key, const uchar *first_rec,
const uchar *second_rec)
{ {
KEY **key= (KEY**) key_p; const KEY *key_info= *(key++); // Start with first key
KEY *key_info= *(key++); // Start with first key
uint key_parts, key_part_num; uint key_parts, key_part_num;
KEY_PART_INFO *key_part= key_info->key_part; KEY_PART_INFO *key_part= key_info->key_part;
uchar *rec0= key_part->field->ptr - key_part->offset; uchar *rec0= key_part->field->ptr - key_part->offset;
@ -642,10 +642,10 @@ next_loop:
@retval +1 key1 > key2 @retval +1 key1 > key2
*/ */
int key_tuple_cmp(KEY_PART_INFO *part, uchar *key1, uchar *key2, int key_tuple_cmp(KEY_PART_INFO *part, const uchar *key1, const uchar *key2,
uint tuple_length) uint tuple_length)
{ {
uchar *key1_end= key1 + tuple_length; const uchar *key1_end= key1 + tuple_length;
int UNINIT_VAR(len); int UNINIT_VAR(len);
int res; int res;
for (;key1 < key1_end; key1 += len, key2 += len, part++) for (;key1 < key1_end; key1 += len, key2 += len, part++)
@ -672,7 +672,6 @@ int key_tuple_cmp(KEY_PART_INFO *part, uchar *key1, uchar *key2,
return 0; return 0;
} }
/** /**
Get hash value for the key from a key buffer Get hash value for the key from a key buffer

6
sql/key.h
View file

@ -38,7 +38,9 @@ int key_cmp(KEY_PART_INFO *key_part, const uchar *key, uint key_length);
ulong key_hashnr(KEY *key_info, uint used_key_parts, const uchar *key); ulong key_hashnr(KEY *key_info, uint used_key_parts, const uchar *key);
bool key_buf_cmp(KEY *key_info, uint used_key_parts, bool key_buf_cmp(KEY *key_info, uint used_key_parts,
const uchar *key1, const uchar *key2); const uchar *key1, const uchar *key2);
extern "C" int key_rec_cmp(void *key_info, uchar *a, uchar *b); extern "C" int key_rec_cmp(const KEY *const *key_info, const uchar *a,
int key_tuple_cmp(KEY_PART_INFO *part, uchar *key1, uchar *key2, uint tuple_length); const uchar *b);
int key_tuple_cmp(KEY_PART_INFO *part, const uchar *key1, const uchar *key2,
uint tuple_length);
#endif /* KEY_INCLUDED */ #endif /* KEY_INCLUDED */

30
sql/multi_range_read.cc
View file

@ -761,9 +761,9 @@ int Mrr_ordered_index_reader::refill_buffer(bool initial)
status_var_increment(thd->status_var.ha_mrr_key_refills_count); status_var_increment(thd->status_var.ha_mrr_key_refills_count);
} }
key_buffer->sort((key_buffer->type() == Lifo_buffer::FORWARD)? key_buffer->sort((key_buffer->type() == Lifo_buffer::FORWARD)
(qsort2_cmp)Mrr_ordered_index_reader::compare_keys_reverse : ? Mrr_ordered_index_reader::compare_keys_reverse
(qsort2_cmp)Mrr_ordered_index_reader::compare_keys, : Mrr_ordered_index_reader::compare_keys,
this); this);
DBUG_RETURN(0); DBUG_RETURN(0);
} }
@ -795,9 +795,11 @@ int Mrr_ordered_index_reader::init(handler *h_arg, RANGE_SEQ_IF *seq_funcs,
} }
static int rowid_cmp_reverse(void *file, uchar *a, uchar *b) static int rowid_cmp_reverse(void *file, const void *a, const void *b)
{ {
return - ((handler*)file)->cmp_ref(a, b); return -(static_cast<handler *>(file))
->cmp_ref(static_cast<const uchar *>(a),
static_cast<const uchar *>(b));
} }
@ -933,7 +935,7 @@ int Mrr_ordered_rndpos_reader::refill_from_index_reader()
if (!index_reader_needs_refill) if (!index_reader_needs_refill)
index_reader->interrupt_read(); index_reader->interrupt_read();
/* Sort the buffer contents by rowid */ /* Sort the buffer contents by rowid */
rowid_buffer->sort((qsort2_cmp)rowid_cmp_reverse, (void*)file); rowid_buffer->sort(rowid_cmp_reverse, (void*)file);
rowid_buffer->setup_reading(file->ref_length, rowid_buffer->setup_reading(file->ref_length,
is_mrr_assoc ? sizeof(range_id_t) : 0); is_mrr_assoc ? sizeof(range_id_t) : 0);
@ -1402,14 +1404,16 @@ void DsMrr_impl::dsmrr_close()
my_qsort2-compatible static member function to compare key tuples my_qsort2-compatible static member function to compare key tuples
*/ */
int Mrr_ordered_index_reader::compare_keys(void* arg, uchar* key1_arg, int Mrr_ordered_index_reader::compare_keys(void *arg, const void *key1_arg_,
uchar* key2_arg) const void *key2_arg_)
{ {
Mrr_ordered_index_reader *reader= (Mrr_ordered_index_reader*)arg; auto key1_arg= static_cast<const uchar *>(key1_arg_);
auto key2_arg= static_cast<const uchar *>(key2_arg_);
auto reader= static_cast<const Mrr_ordered_index_reader *>(arg);
TABLE *table= reader->file->get_table(); TABLE *table= reader->file->get_table();
KEY_PART_INFO *part= table->key_info[reader->file->active_index].key_part; KEY_PART_INFO *part= table->key_info[reader->file->active_index].key_part;
uchar *key1, *key2; const uchar *key1, *key2;
if (reader->keypar.use_key_pointers) if (reader->keypar.use_key_pointers)
{ {
/* the buffer stores pointers to keys, get to the keys */ /* the buffer stores pointers to keys, get to the keys */
@ -1426,8 +1430,8 @@ int Mrr_ordered_index_reader::compare_keys(void* arg, uchar* key1_arg,
} }
int Mrr_ordered_index_reader::compare_keys_reverse(void* arg, uchar* key1, int Mrr_ordered_index_reader::compare_keys_reverse(void *arg, const void *key1,
uchar* key2) const void *key2)
{ {
return -compare_keys(arg, key1, key2); return -compare_keys(arg, key1, key2);
} }

7
sql/multi_range_read.h
View file

@ -346,9 +346,10 @@ private:
*/ */
bool read_was_interrupted; bool read_was_interrupted;
static int compare_keys(void* arg, uchar* key1, uchar* key2); static int compare_keys(void *arg, const void *key1, const void *key2);
static int compare_keys_reverse(void* arg, uchar* key1, uchar* key2); static int compare_keys_reverse(void *arg, const void *key1,
const void *key2);
friend class Key_value_records_iterator; friend class Key_value_records_iterator;
friend class DsMrr_impl; friend class DsMrr_impl;
friend class Mrr_ordered_rndpos_reader; friend class Mrr_ordered_rndpos_reader;

6
sql/mysqld.cc
View file

@ -7679,10 +7679,10 @@ static void print_version(void)
} }
/** Compares two options' names, treats - and _ the same */ /** Compares two options' names, treats - and _ the same */
static int option_cmp(my_option *a, my_option *b) static int option_cmp(const void *a, const void *b)
{ {
const char *sa= a->name; const char *sa= static_cast<const my_option *>(a)->name;
const char *sb= b->name; const char *sb= static_cast<const my_option *>(b)->name;
for (; *sa || *sb; sa++, sb++) for (; *sa || *sb; sa++, sb++)
{ {
if (*sa < *sb) if (*sa < *sb)

32
sql/opt_range.cc
View file

@ -1749,11 +1749,13 @@ QUICK_ROR_UNION_SELECT::QUICK_ROR_UNION_SELECT(THD *thd_param,
C_MODE_START C_MODE_START
static int QUICK_ROR_UNION_SELECT_queue_cmp(void *arg, uchar *val1, uchar *val2) static int QUICK_ROR_UNION_SELECT_queue_cmp(void *arg, const void *val1_,
const void *val2_)
{ {
QUICK_ROR_UNION_SELECT *self= (QUICK_ROR_UNION_SELECT*)arg; auto self= static_cast<QUICK_ROR_UNION_SELECT *>(arg);
return self->head->file->cmp_ref(((QUICK_SELECT_I*)val1)->last_rowid, auto val1= static_cast<const QUICK_SELECT_I *>(val1_);
((QUICK_SELECT_I*)val2)->last_rowid); auto val2= static_cast<const QUICK_SELECT_I *>(val2_);
return self->head->file->cmp_ref(val1->last_rowid, val2->last_rowid);
} }
C_MODE_END C_MODE_END
@ -3346,8 +3348,11 @@ double records_in_column_ranges(PARAM *param, uint idx,
*/ */
static static
int cmp_quick_ranges(TABLE *table, uint *a, uint *b) int cmp_quick_ranges(void *table_, const void *a_, const void *b_)
{ {
TABLE *table= static_cast<TABLE *>(table_);
const uint *a= static_cast<const uint *>(a_);
const uint *b= static_cast<const uint *>(b_);
int tmp= CMP_NUM(table->opt_range[*a].rows, table->opt_range[*b].rows); int tmp= CMP_NUM(table->opt_range[*a].rows, table->opt_range[*b].rows);
if (tmp) if (tmp)
return tmp; return tmp;
@ -3440,9 +3445,8 @@ bool calculate_cond_selectivity_for_table(THD *thd, TABLE *table, Item **cond)
if (table->opt_range_keys.is_set(keynr)) if (table->opt_range_keys.is_set(keynr))
optimal_key_order[ranges++]= keynr; optimal_key_order[ranges++]= keynr;
my_qsort2(optimal_key_order, ranges, my_qsort2(optimal_key_order, ranges, sizeof(optimal_key_order[0]),
sizeof(optimal_key_order[0]), cmp_quick_ranges, table);
(qsort2_cmp) cmp_quick_ranges, table);
for (range_index= 0 ; range_index < ranges ; range_index++) for (range_index= 0 ; range_index < ranges ; range_index++)
{ {
@ -5751,8 +5755,10 @@ bool create_fields_bitmap(PARAM *param, MY_BITMAP *fields_bitmap)
/* Compare two indexes scans for sort before search for the best intersection */ /* Compare two indexes scans for sort before search for the best intersection */
static static
int cmp_intersect_index_scan(INDEX_SCAN_INFO **a, INDEX_SCAN_INFO **b) int cmp_intersect_index_scan(const void *a_, const void *b_)
{ {
auto a= static_cast<const INDEX_SCAN_INFO *const *>(a_);
auto b= static_cast<const INDEX_SCAN_INFO *const *>(b_);
return (*a)->records < (*b)->records ? return (*a)->records < (*b)->records ?
-1 : (*a)->records == (*b)->records ? 0 : 1; -1 : (*a)->records == (*b)->records ? 0 : 1;
} }
@ -6685,8 +6691,10 @@ ROR_SCAN_INFO *make_ror_scan(const PARAM *param, int idx, SEL_ARG *sel_arg)
1 a > b 1 a > b
*/ */
static int cmp_ror_scan_info(ROR_SCAN_INFO** a, ROR_SCAN_INFO** b) static int cmp_ror_scan_info(const void *a_, const void *b_)
{ {
auto a= static_cast<const ROR_SCAN_INFO *const *>(a_);
auto b= static_cast<const ROR_SCAN_INFO *const *>(b_);
double val1= rows2double((*a)->records) * (*a)->key_rec_length; double val1= rows2double((*a)->records) * (*a)->key_rec_length;
double val2= rows2double((*b)->records) * (*b)->key_rec_length; double val2= rows2double((*b)->records) * (*b)->key_rec_length;
return (val1 < val2)? -1: (val1 == val2)? 0 : 1; return (val1 < val2)? -1: (val1 == val2)? 0 : 1;
@ -6709,8 +6717,10 @@ static int cmp_ror_scan_info(ROR_SCAN_INFO** a, ROR_SCAN_INFO** b)
1 a > b 1 a > b
*/ */
static int cmp_ror_scan_info_covering(ROR_SCAN_INFO** a, ROR_SCAN_INFO** b) static int cmp_ror_scan_info_covering(const void *a_, const void *b_)
{ {
auto a= static_cast<const ROR_SCAN_INFO *const *>(a_);
auto b= static_cast<const ROR_SCAN_INFO *const *>(b_);
if ((*a)->used_fields_covered > (*b)->used_fields_covered) if ((*a)->used_fields_covered > (*b)->used_fields_covered)
return -1; return -1;
if ((*a)->used_fields_covered < (*b)->used_fields_covered) if ((*a)->used_fields_covered < (*b)->used_fields_covered)

4
sql/opt_split.cc
View file

@ -672,8 +672,10 @@ add_ext_keyuse_for_splitting(Dynamic_array<KEYUSE_EXT> *ext_keyuses,
static int static int
sort_ext_keyuse(KEYUSE_EXT *a, KEYUSE_EXT *b) sort_ext_keyuse(const void *a_, const void *b_)
{ {
const KEYUSE_EXT *a= static_cast<const KEYUSE_EXT *>(a_);
const KEYUSE_EXT *b= static_cast<const KEYUSE_EXT *>(b_);
if (a->table->tablenr != b->table->tablenr) if (a->table->tablenr != b->table->tablenr)
return (int) (a->table->tablenr - b->table->tablenr); return (int) (a->table->tablenr - b->table->tablenr);
if (a->key != b->key) if (a->key != b->key)

6
sql/records.cc
View file

@ -43,7 +43,7 @@ template<bool,bool> static int rr_unpack_from_buffer(READ_RECORD *info);
int rr_from_pointers(READ_RECORD *info); int rr_from_pointers(READ_RECORD *info);
static int rr_from_cache(READ_RECORD *info); static int rr_from_cache(READ_RECORD *info);
static int init_rr_cache(THD *thd, READ_RECORD *info); static int init_rr_cache(THD *thd, READ_RECORD *info);
static int rr_cmp(uchar *a,uchar *b); static int rr_cmp(const void *a, const void *b);
static int rr_index_first(READ_RECORD *info); static int rr_index_first(READ_RECORD *info);
static int rr_index_last(READ_RECORD *info); static int rr_index_last(READ_RECORD *info);
static int rr_index(READ_RECORD *info); static int rr_index(READ_RECORD *info);
@ -772,8 +772,10 @@ static int rr_from_cache(READ_RECORD *info)
} /* rr_from_cache */ } /* rr_from_cache */
static int rr_cmp(uchar *a,uchar *b) static int rr_cmp(const void *a_, const void *b_)
{ {
auto a= static_cast<const uchar *>(a_);
auto b= static_cast<const uchar *>(b_);
if (a[0] != b[0]) if (a[0] != b[0])
return (int) a[0] - (int) b[0]; return (int) a[0] - (int) b[0];
if (a[1] != b[1]) if (a[1] != b[1])

10
sql/rowid_filter.cc
View file

@ -172,12 +172,12 @@ Rowid_filter_container *Range_rowid_filter_cost_info::create_container()
} }
static static int compare_range_rowid_filter_cost_info_by_a(const void *p1_,
int compare_range_rowid_filter_cost_info_by_a( const void *p2_)
Range_rowid_filter_cost_info **filter_ptr_1,
Range_rowid_filter_cost_info **filter_ptr_2)
{ {
double diff= (*filter_ptr_2)->get_a() - (*filter_ptr_1)->get_a(); auto p1= static_cast<const Range_rowid_filter_cost_info *const *>(p1_);
auto p2= static_cast<const Range_rowid_filter_cost_info *const *>(p2_);
double diff= (*p2)->get_a() - (*p1)->get_a();
return (diff < 0 ? -1 : (diff > 0 ? 1 : 0)); return (diff < 0 ? -1 : (diff > 0 ? 1 : 0));
} }

9
sql/rowid_filter.h
View file

@ -343,11 +343,10 @@ public:
uint elements() { return (uint) (array->elements() / elem_size); } uint elements() { return (uint) (array->elements() / elem_size); }
void sort (int (*cmp) (void *ctxt, const void *el1, const void *el2), void sort(qsort_cmp2 cmp, void *cmp_arg)
void *cmp_arg)
{ {
my_qsort2(array->front(), array->elements()/elem_size, my_qsort2(array->front(), array->elements() / elem_size, elem_size, cmp,
elem_size, (qsort2_cmp) cmp, cmp_arg); cmp_arg);
} }
bool is_empty() { return elements() == 0; } bool is_empty() { return elements() == 0; }
@ -464,7 +463,7 @@ public:
Rowid_filter_container *create_container(); Rowid_filter_container *create_container();
double get_a() { return a; } double get_a() const { return a; }
void trace_info(THD *thd); void trace_info(THD *thd);

6
sql/rpl_gtid.cc
View file

@ -2925,10 +2925,10 @@ gtid_waiting::destroy()
static int static int
cmp_queue_elem(void *, uchar *a, uchar *b) cmp_queue_elem(void *, const void *a, const void *b)
{ {
uint64 seq_no_a= *(uint64 *)a; auto seq_no_a= *(static_cast<const uint64 *>(a));
uint64 seq_no_b= *(uint64 *)b; auto seq_no_b= *(static_cast<const uint64 *>(b));
if (seq_no_a < seq_no_b) if (seq_no_a < seq_no_b)
return -1; return -1;
else if (seq_no_a == seq_no_b) else if (seq_no_a == seq_no_b)

4
sql/set_var.cc
View file

@ -614,8 +614,10 @@ int mysql_del_sys_var_chain(sys_var *first)
} }
static int show_cmp(SHOW_VAR *a, SHOW_VAR *b) static int show_cmp(const void *a_, const void *b_)
{ {
const SHOW_VAR *a= static_cast<const SHOW_VAR *>(a_);
const SHOW_VAR *b= static_cast<const SHOW_VAR *>(b_);
return strcmp(a->name, b->name); return strcmp(a->name, b->name);
} }

6
sql/slave.cc
View file

@ -3383,9 +3383,11 @@ static bool send_show_master_info_data(THD *thd, Master_info *mi, bool full,
/* Used to sort connections by name */ /* Used to sort connections by name */
static int cmp_mi_by_name(const Master_info **arg1, static int cmp_mi_by_name(const void *arg1_,
const Master_info **arg2) const void *arg2_)
{ {
auto arg1= static_cast<const Master_info *const *>(arg1_);
auto arg2= static_cast<const Master_info *const *>(arg2_);
return my_strcasecmp(system_charset_info, (*arg1)->connection_name.str, return my_strcasecmp(system_charset_info, (*arg1)->connection_name.str,
(*arg2)->connection_name.str); (*arg2)->connection_name.str);
} }

5
sql/sp_head.cc
View file

@ -997,9 +997,10 @@ sp_head::create_result_field(uint field_max_length, const LEX_CSTRING *field_nam
} }
int cmp_rqp_locations(Rewritable_query_parameter * const *a, int cmp_rqp_locations(const void *a_, const void *b_)
Rewritable_query_parameter * const *b)
{ {
auto a= static_cast<const Rewritable_query_parameter *const *>(a_);
auto b= static_cast<const Rewritable_query_parameter *const *>(b_);
return (int)((*a)->pos_in_query - (*b)->pos_in_query); return (int)((*a)->pos_in_query - (*b)->pos_in_query);
} }

32
sql/sql_acl.cc
View file

@ -657,7 +657,6 @@ bool ROLE_GRANT_PAIR::init(MEM_ROOT *mem, const char *username,
static DYNAMIC_ARRAY acl_hosts, acl_users, acl_proxy_users; static DYNAMIC_ARRAY acl_hosts, acl_users, acl_proxy_users;
static Dynamic_array<ACL_DB> acl_dbs(PSI_INSTRUMENT_MEM, 0U, 50U); static Dynamic_array<ACL_DB> acl_dbs(PSI_INSTRUMENT_MEM, 0U, 50U);
typedef Dynamic_array<ACL_DB>::CMP_FUNC acl_dbs_cmp;
static HASH acl_roles; static HASH acl_roles;
/* /*
An hash containing mappings user <--> role An hash containing mappings user <--> role
@ -675,10 +674,10 @@ static DYNAMIC_ARRAY acl_wild_hosts;
static Hash_filo<acl_entry> *acl_cache; static Hash_filo<acl_entry> *acl_cache;
static uint grant_version=0; /* Version of priv tables. incremented by acl_load */ static uint grant_version=0; /* Version of priv tables. incremented by acl_load */
static privilege_t get_access(TABLE *form, uint fieldnr, uint *next_field=0); static privilege_t get_access(TABLE *form, uint fieldnr, uint *next_field=0);
static int acl_compare(const ACL_ACCESS *a, const ACL_ACCESS *b); static int acl_compare(const void *a, const void *b);
static int acl_user_compare(const ACL_USER *a, const ACL_USER *b); static int acl_user_compare(const void *a, const void *b);
static void rebuild_acl_users(); static void rebuild_acl_users();
static int acl_db_compare(const ACL_DB *a, const ACL_DB *b); static int acl_db_compare(const void *a, const void *b);
static void rebuild_acl_dbs(); static void rebuild_acl_dbs();
static void init_check_host(void); static void init_check_host(void);
static void rebuild_check_host(void); static void rebuild_check_host(void);
@ -3004,8 +3003,10 @@ static privilege_t get_access(TABLE *form, uint fieldnr, uint *next_field)
} }
static int acl_compare(const ACL_ACCESS *a, const ACL_ACCESS *b) static int acl_compare(const void *a_, const void *b_)
{ {
const ACL_ACCESS *a= static_cast<const ACL_ACCESS *>(a_);
const ACL_ACCESS *b= static_cast<const ACL_ACCESS *>(b_);
if (a->sort > b->sort) if (a->sort > b->sort)
return -1; return -1;
if (a->sort < b->sort) if (a->sort < b->sort)
@ -3013,8 +3014,11 @@ static int acl_compare(const ACL_ACCESS *a, const ACL_ACCESS *b)
return 0; return 0;
} }
static int acl_user_compare(const ACL_USER *a, const ACL_USER *b) static int acl_user_compare(const void *a_, const void *b_)
{ {
const ACL_USER *a= static_cast<const ACL_USER *>(a_);
const ACL_USER *b= static_cast<const ACL_USER *>(b_);
int res= strcmp(a->user.str, b->user.str); int res= strcmp(a->user.str, b->user.str);
if (res) if (res)
return res; return res;
@ -3033,8 +3037,10 @@ static int acl_user_compare(const ACL_USER *a, const ACL_USER *b)
return -strcmp(a->host.hostname, b->host.hostname); return -strcmp(a->host.hostname, b->host.hostname);
} }
static int acl_db_compare(const ACL_DB *a, const ACL_DB *b) static int acl_db_compare(const void *a_, const void *b_)
{ {
const ACL_DB *a= static_cast<const ACL_DB *>(a_);
const ACL_DB *b= static_cast<const ACL_DB *>(b_);
int res= strcmp(a->user, b->user); int res= strcmp(a->user, b->user);
if (res) if (res)
return res; return res;
@ -6522,8 +6528,10 @@ static bool merge_role_global_privileges(ACL_ROLE *grantee)
return old != grantee->access; return old != grantee->access;
} }
static int db_name_sort(const int *db1, const int *db2) static int db_name_sort(const void *db1_, const void *db2_)
{ {
auto db1= static_cast<const int *>(db1_);
auto db2= static_cast<const int *>(db2_);
return strcmp(acl_dbs.at(*db1).db, acl_dbs.at(*db2).db); return strcmp(acl_dbs.at(*db1).db, acl_dbs.at(*db2).db);
} }
@ -6676,8 +6684,10 @@ static bool merge_role_db_privileges(ACL_ROLE *grantee, const char *dbname,
return update_flags; return update_flags;
} }
static int table_name_sort(GRANT_TABLE * const *tbl1, GRANT_TABLE * const *tbl2) static int table_name_sort(const void *tbl1_, const void *tbl2_)
{ {
auto tbl1= static_cast<const GRANT_TABLE *const *>(tbl1_);
auto tbl2= static_cast<const GRANT_TABLE *const *>(tbl2_);
int res = strcmp((*tbl1)->db, (*tbl2)->db); int res = strcmp((*tbl1)->db, (*tbl2)->db);
if (res) return res; if (res) return res;
return strcmp((*tbl1)->tname, (*tbl2)->tname); return strcmp((*tbl1)->tname, (*tbl2)->tname);
@ -6878,8 +6888,10 @@ static bool merge_role_table_and_column_privileges(ACL_ROLE *grantee,
return update_flags; return update_flags;
} }
static int routine_name_sort(GRANT_NAME * const *r1, GRANT_NAME * const *r2) static int routine_name_sort(const void *r1_, const void *r2_)
{ {
auto r1= static_cast<const GRANT_NAME *const *>(r1_);
auto r2= static_cast<const GRANT_NAME *const *>(r2_);
int res= strcmp((*r1)->db, (*r2)->db); int res= strcmp((*r1)->db, (*r2)->db);
if (res) return res; if (res) return res;
return strcmp((*r1)->tname, (*r2)->tname); return strcmp((*r1)->tname, (*r2)->tname);

26
sql/sql_analyse.cc
View file

@ -38,32 +38,40 @@
#define MAX_TREEMEM 8192 #define MAX_TREEMEM 8192
#define MAX_TREE_ELEMENTS 256 #define MAX_TREE_ELEMENTS 256
int sortcmp2(void* cmp_arg __attribute__((unused)), int sortcmp2(void *, const void *a_, const void *b_)
const String *a,const String *b)
{ {
const String *a= static_cast<const String*>(a_);
const String *b= static_cast<const String*>(b_);
return sortcmp(a,b,a->charset()); return sortcmp(a,b,a->charset());
} }
int compare_double2(void* cmp_arg __attribute__((unused)), int compare_double2(void *, const void *s_, const void *t_)
const double *s, const double *t)
{ {
const double *s= static_cast<const double*>(s_);
const double *t= static_cast<const double*>(t_);
return compare_double(s,t); return compare_double(s,t);
} }
int compare_longlong2(void* cmp_arg __attribute__((unused)), int compare_longlong2(void *, const void *s_, const void *t_)
const longlong *s, const longlong *t)
{ {
const longlong *s= static_cast<const longlong*>(s_);
const longlong *t= static_cast<const longlong*>(t_);
return compare_longlong(s,t); return compare_longlong(s,t);
} }
int compare_ulonglong2(void* cmp_arg __attribute__((unused)), int compare_ulonglong2(void *, const void *s_, const void *t_)
const ulonglong *s, const ulonglong *t)
{ {
const ulonglong *s= static_cast<const ulonglong*>(s_);
const ulonglong *t= static_cast<const ulonglong*>(t_);
return compare_ulonglong(s,t); return compare_ulonglong(s,t);
} }
int compare_decimal2(int* len, const char *s, const char *t) int compare_decimal2(void *_len, const void *s_, const void *t_)
{ {
int *len= static_cast<int *>(_len);
const char *s= static_cast<const char *>(s_);
const char *t= static_cast<const char *>(t_);
return memcmp(s, t, *len); return memcmp(s, t, *len);
} }

45
sql/sql_analyse.h
View file

@ -57,15 +57,12 @@ uint check_ulonglong(const char *str, uint length);
bool get_ev_num_info(EV_NUM_INFO *ev_info, NUM_INFO *info, const char *num); bool get_ev_num_info(EV_NUM_INFO *ev_info, NUM_INFO *info, const char *num);
bool test_if_number(NUM_INFO *info, const char *str, uint str_len); bool test_if_number(NUM_INFO *info, const char *str, uint str_len);
int compare_double(const double *s, const double *t); int compare_double(const double *s, const double *t);
int compare_double2(void* cmp_arg __attribute__((unused)), int compare_double2(void *, const void *s, const void *t);
const double *s, const double *t);
int compare_longlong(const longlong *s, const longlong *t); int compare_longlong(const longlong *s, const longlong *t);
int compare_longlong2(void* cmp_arg __attribute__((unused)), int compare_longlong2(void *, const void *s, const void *t);
const longlong *s, const longlong *t);
int compare_ulonglong(const ulonglong *s, const ulonglong *t); int compare_ulonglong(const ulonglong *s, const ulonglong *t);
int compare_ulonglong2(void* cmp_arg __attribute__((unused)), int compare_ulonglong2(void *, const void *s, const void *t);
const ulonglong *s, const ulonglong *t); int compare_decimal2(void *len, const void *s, const void *t);
int compare_decimal2(int* len, const char *s, const char *t);
Procedure *proc_analyse_init(THD *thd, ORDER *param, select_result *result, Procedure *proc_analyse_init(THD *thd, ORDER *param, select_result *result,
List<Item> &field_list); List<Item> &field_list);
int free_string(void* str, TREE_FREE, void*); int free_string(void* str, TREE_FREE, void*);
@ -102,8 +99,7 @@ public:
int collect_string(String *element, element_count count, int collect_string(String *element, element_count count,
TREE_INFO *info); TREE_INFO *info);
int sortcmp2(void* cmp_arg __attribute__((unused)), int sortcmp2(void *, const void *a, const void *b);
const String *a,const String *b);
class field_str :public field_info class field_str :public field_info
{ {
@ -120,8 +116,10 @@ public:
max_arg("",default_charset_info), sum(0), max_arg("",default_charset_info), sum(0),
must_be_blob(0), was_zero_fill(0), must_be_blob(0), was_zero_fill(0),
was_maybe_zerofill(0), can_be_still_num(1) was_maybe_zerofill(0), can_be_still_num(1)
{ init_tree(&tree, 0, 0, sizeof(String), (qsort_cmp2) sortcmp2, {
free_string, NULL, MYF(MY_THREAD_SPECIFIC)); }; init_tree(&tree, 0, 0, sizeof(String), sortcmp2, free_string, NULL,
MYF(MY_THREAD_SPECIFIC));
};
void add() override; void add() override;
void get_opt_type(String*, ha_rows) override; void get_opt_type(String*, ha_rows) override;
@ -161,8 +159,8 @@ public:
field_decimal(Item* a, analyse* b) :field_info(a,b) field_decimal(Item* a, analyse* b) :field_info(a,b)
{ {
bin_size= my_decimal_get_binary_size(a->max_length, a->decimals); bin_size= my_decimal_get_binary_size(a->max_length, a->decimals);
init_tree(&tree, 0, 0, bin_size, (qsort_cmp2)compare_decimal2, init_tree(&tree, 0, 0, bin_size, compare_decimal2, 0, (void *) &bin_size,
0, (void *)&bin_size, MYF(MY_THREAD_SPECIFIC)); MYF(MY_THREAD_SPECIFIC));
}; };
void add() override; void add() override;
@ -189,9 +187,10 @@ class field_real: public field_info
public: public:
field_real(Item* a, analyse* b) :field_info(a,b), field_real(Item* a, analyse* b) :field_info(a,b),
min_arg(0), max_arg(0), sum(0), sum_sqr(0), max_notzero_dec_len(0) min_arg(0), max_arg(0), sum(0), sum_sqr(0), max_notzero_dec_len(0)
{ init_tree(&tree, 0, 0, sizeof(double), {
(qsort_cmp2) compare_double2, NULL, NULL, init_tree(&tree, 0, 0, sizeof(double), compare_double2, NULL, NULL,
MYF(MY_THREAD_SPECIFIC)); } MYF(MY_THREAD_SPECIFIC));
}
void add() override; void add() override;
void get_opt_type(String*, ha_rows) override; void get_opt_type(String*, ha_rows) override;
@ -244,9 +243,10 @@ class field_longlong: public field_info
public: public:
field_longlong(Item* a, analyse* b) :field_info(a,b), field_longlong(Item* a, analyse* b) :field_info(a,b),
min_arg(0), max_arg(0), sum(0), sum_sqr(0) min_arg(0), max_arg(0), sum(0), sum_sqr(0)
{ init_tree(&tree, 0, 0, sizeof(longlong), {
(qsort_cmp2) compare_longlong2, NULL, NULL, init_tree(&tree, 0, 0, sizeof(longlong), compare_longlong2, NULL, NULL,
MYF(MY_THREAD_SPECIFIC)); } MYF(MY_THREAD_SPECIFIC));
}
void add() override; void add() override;
void get_opt_type(String*, ha_rows) override; void get_opt_type(String*, ha_rows) override;
@ -290,9 +290,10 @@ class field_ulonglong: public field_info
public: public:
field_ulonglong(Item* a, analyse * b) :field_info(a,b), field_ulonglong(Item* a, analyse * b) :field_info(a,b),
min_arg(0), max_arg(0), sum(0),sum_sqr(0) min_arg(0), max_arg(0), sum(0),sum_sqr(0)
{ init_tree(&tree, 0, 0, sizeof(ulonglong), {
(qsort_cmp2) compare_ulonglong2, NULL, NULL, init_tree(&tree, 0, 0, sizeof(ulonglong), compare_ulonglong2, NULL, NULL,
MYF(MY_THREAD_SPECIFIC)); } MYF(MY_THREAD_SPECIFIC));
}
void add() override; void add() override;
void get_opt_type(String*, ha_rows) override; void get_opt_type(String*, ha_rows) override;
String *get_min_arg(String *s) override { s->set(min_arg,my_thd_charset); return s; } String *get_min_arg(String *s) override { s->set(min_arg,my_thd_charset); return s; }

11
sql/sql_array.h
View file

@ -289,17 +289,14 @@ public:
delete_dynamic(&array); delete_dynamic(&array);
} }
typedef int (*CMP_FUNC)(const Elem *el1, const Elem *el2); void sort(int (*cmp_func)(const void *, const void *))
void sort(CMP_FUNC cmp_func)
{ {
my_qsort(array.buffer, array.elements, sizeof(Elem), (qsort_cmp)cmp_func); my_qsort(array.buffer, array.elements, sizeof(Elem), cmp_func);
} }
typedef int (*CMP_FUNC2)(void *, const Elem *el1, const Elem *el2); void sort(qsort_cmp2 cmp_func, void *data)
void sort(CMP_FUNC2 cmp_func, void *data)
{ {
my_qsort2(array.buffer, array.elements, sizeof(Elem), (qsort2_cmp)cmp_func, data); my_qsort2(array.buffer, array.elements, sizeof(Elem), cmp_func, data);
} }
}; };

5
sql/sql_base.h
View file

@ -323,10 +323,9 @@ int dynamic_column_error_message(enum_dyncol_func_result rc);
/* open_and_lock_tables with optional derived handling */ /* open_and_lock_tables with optional derived handling */
int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived); int open_and_lock_tables_derived(THD *thd, TABLE_LIST *tables, bool derived);
extern "C" int simple_raw_key_cmp(void* arg, const void* key1, extern "C" qsort_cmp2 simple_raw_key_cmp;
const void* key2);
extern "C" int count_distinct_walk(void *elem, element_count count, void *arg); extern "C" int count_distinct_walk(void *elem, element_count count, void *arg);
int simple_str_key_cmp(void* arg, uchar* key1, uchar* key2); int simple_str_key_cmp(void *arg, const void *key1, const void *key2);
extern Item **not_found_item; extern Item **not_found_item;
extern Field *not_found_field; extern Field *not_found_field;

8
sql/sql_class.h
View file

@ -6759,10 +6759,10 @@ struct SORT_FIELD_ATTR
CHARSET_INFO *cs; CHARSET_INFO *cs;
uint pack_sort_string(uchar *to, const Binary_string *str, uint pack_sort_string(uchar *to, const Binary_string *str,
CHARSET_INFO *cs) const; CHARSET_INFO *cs) const;
int compare_packed_fixed_size_vals(uchar *a, size_t *a_len, int compare_packed_fixed_size_vals(const uchar *a, size_t *a_len,
uchar *b, size_t *b_len); const uchar *b, size_t *b_len);
int compare_packed_varstrings(uchar *a, size_t *a_len, int compare_packed_varstrings(const uchar *a, size_t *a_len,
uchar *b, size_t *b_len); const uchar *b, size_t *b_len);
bool check_if_packing_possible(THD *thd) const; bool check_if_packing_possible(THD *thd) const;
bool is_variable_sized() { return type == VARIABLE_SIZE; } bool is_variable_sized() { return type == VARIABLE_SIZE; }
void set_length_and_original_length(THD *thd, uint length_arg); void set_length_and_original_length(THD *thd, uint length_arg);

7
sql/sql_delete.cc
View file

@ -1108,10 +1108,11 @@ int mysql_prepare_delete(THD *thd, TABLE_LIST *table_list, Item **conds,
***************************************************************************/ ***************************************************************************/
extern "C" int refpos_order_cmp(void* arg, const void *a,const void *b) extern "C" int refpos_order_cmp(void *arg, const void *a, const void *b)
{ {
handler *file= (handler*)arg; auto file= static_cast<handler *>(arg);
return file->cmp_ref((const uchar*)a, (const uchar*)b); return file->cmp_ref(static_cast<const uchar *>(a),
static_cast<const uchar *>(b));
} }
/* /*

2
sql/sql_lifo_buffer.h
View file

@ -117,7 +117,7 @@ public:
bool is_empty() { return used_size() == 0; } bool is_empty() { return used_size() == 0; }
virtual bool read() = 0; virtual bool read() = 0;
void sort(qsort2_cmp cmp_func, void *cmp_func_arg) void sort(qsort_cmp2 cmp_func, void *cmp_func_arg)
{ {
size_t elem_size= size1 + size2; size_t elem_size= size1 + size2;
size_t n_elements= used_size() / elem_size; size_t n_elements= used_size() / elem_size;

39
sql/sql_select.cc
View file

@ -100,7 +100,7 @@ static bool update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,
uint tables, COND *conds, uint tables, COND *conds,
table_map table_map, SELECT_LEX *select_lex, table_map table_map, SELECT_LEX *select_lex,
SARGABLE_PARAM **sargables); SARGABLE_PARAM **sargables);
static int sort_keyuse(KEYUSE *a,KEYUSE *b); static int sort_keyuse(const void *a, const void *b);
static bool are_tables_local(JOIN_TAB *jtab, table_map used_tables); static bool are_tables_local(JOIN_TAB *jtab, table_map used_tables);
static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse, static bool create_ref_for_key(JOIN *join, JOIN_TAB *j, KEYUSE *org_keyuse,
bool allow_full_scan, table_map used_tables); bool allow_full_scan, table_map used_tables);
@ -119,9 +119,9 @@ static bool best_extension_by_limited_search(JOIN *join,
uint use_cond_selectivity); uint use_cond_selectivity);
static uint determine_search_depth(JOIN* join); static uint determine_search_depth(JOIN* join);
C_MODE_START C_MODE_START
static int join_tab_cmp(const void *dummy, const void* ptr1, const void* ptr2); static int join_tab_cmp(void *dummy, const void* ptr1, const void* ptr2);
static int join_tab_cmp_straight(const void *dummy, const void* ptr1, const void* ptr2); static int join_tab_cmp_straight(void *dummy, const void* ptr1, const void* ptr2);
static int join_tab_cmp_embedded_first(const void *emb, const void* ptr1, const void *ptr2); static int join_tab_cmp_embedded_first(void *emb, const void* ptr1, const void *ptr2);
C_MODE_END C_MODE_END
static uint cache_record_length(JOIN *join,uint index); static uint cache_record_length(JOIN *join,uint index);
static store_key *get_store_key(THD *thd, static store_key *get_store_key(THD *thd,
@ -6838,8 +6838,10 @@ add_ft_keys(DYNAMIC_ARRAY *keyuse_array,
static int static int
sort_keyuse(KEYUSE *a,KEYUSE *b) sort_keyuse(const void *a_, const void *b_)
{ {
const KEYUSE *a= static_cast<const KEYUSE *>(a_);
const KEYUSE *b= static_cast<const KEYUSE *>(b_);
int res; int res;
if (a->table->tablenr != b->table->tablenr) if (a->table->tablenr != b->table->tablenr)
return (int) (a->table->tablenr - b->table->tablenr); return (int) (a->table->tablenr - b->table->tablenr);
@ -8650,7 +8652,7 @@ choose_plan(JOIN *join, table_map join_tables)
join->cur_embedding_map= 0; join->cur_embedding_map= 0;
reset_nj_counters(join, join->join_list); reset_nj_counters(join, join->join_list);
qsort2_cmp jtab_sort_func; qsort_cmp2 jtab_sort_func;
if (join->emb_sjm_nest) if (join->emb_sjm_nest)
{ {
@ -8734,7 +8736,7 @@ choose_plan(JOIN *join, table_map join_tables)
1 - jt1 > jt2 1 - jt1 > jt2
*/ */
static int compare_embedding_subqueries(JOIN_TAB *jt1, JOIN_TAB *jt2) static int compare_embedding_subqueries(const JOIN_TAB *jt1, const JOIN_TAB *jt2)
{ {
/* Determine if the first table is originally from a subquery */ /* Determine if the first table is originally from a subquery */
TABLE_LIST *tbl1= jt1->table->pos_in_table_list; TABLE_LIST *tbl1= jt1->table->pos_in_table_list;
@ -8809,10 +8811,10 @@ static int compare_embedding_subqueries(JOIN_TAB *jt1, JOIN_TAB *jt2)
*/ */
static int static int
join_tab_cmp(const void *dummy, const void* ptr1, const void* ptr2) join_tab_cmp(void *, const void* ptr1, const void* ptr2)
{ {
JOIN_TAB *jt1= *(JOIN_TAB**) ptr1; auto jt1= *(static_cast<const JOIN_TAB *const *>(ptr1));
JOIN_TAB *jt2= *(JOIN_TAB**) ptr2; auto jt2= *(static_cast<const JOIN_TAB *const *>(ptr2));
int cmp; int cmp;
if ((cmp= compare_embedding_subqueries(jt1, jt2)) != 0) if ((cmp= compare_embedding_subqueries(jt1, jt2)) != 0)
@ -8839,10 +8841,10 @@ join_tab_cmp(const void *dummy, const void* ptr1, const void* ptr2)
*/ */
static int static int
join_tab_cmp_straight(const void *dummy, const void* ptr1, const void* ptr2) join_tab_cmp_straight(void *, const void* ptr1, const void* ptr2)
{ {
JOIN_TAB *jt1= *(JOIN_TAB**) ptr1; auto jt1= *(static_cast<const JOIN_TAB *const *>(ptr1));
JOIN_TAB *jt2= *(JOIN_TAB**) ptr2; auto jt2= *(static_cast<const JOIN_TAB *const *>(ptr2));
/* /*
We don't do subquery flattening if the parent or child select has We don't do subquery flattening if the parent or child select has
@ -8870,11 +8872,11 @@ join_tab_cmp_straight(const void *dummy, const void* ptr1, const void* ptr2)
*/ */
static int static int
join_tab_cmp_embedded_first(const void *emb, const void* ptr1, const void* ptr2) join_tab_cmp_embedded_first(void *emb, const void* ptr1, const void* ptr2)
{ {
const TABLE_LIST *emb_nest= (TABLE_LIST*) emb; TABLE_LIST *emb_nest= static_cast<TABLE_LIST *>(emb);
JOIN_TAB *jt1= *(JOIN_TAB**) ptr1; auto jt1= *(static_cast<const JOIN_TAB *const *>(ptr1));
JOIN_TAB *jt2= *(JOIN_TAB**) ptr2; auto jt2= *(static_cast<const JOIN_TAB *const *>(ptr2));
if (jt1->emb_sj_nest == emb_nest && jt2->emb_sj_nest != emb_nest) if (jt1->emb_sj_nest == emb_nest && jt2->emb_sj_nest != emb_nest)
return -1; return -1;
@ -25079,8 +25081,7 @@ static int remove_dup_with_hash_index(THD *thd, TABLE *table,
(*field_length++)= (*ptr)->sort_length(); (*field_length++)= (*ptr)->sort_length();
if (my_hash_init(key_memory_hash_index_key_buffer, &hash, &my_charset_bin, if (my_hash_init(key_memory_hash_index_key_buffer, &hash, &my_charset_bin,
(uint) file->stats.records, 0, key_length, (uint) file->stats.records, 0, key_length, 0, 0, 0))
(my_hash_get_key) 0, 0, 0))
{ {
my_free(key_buffer); my_free(key_buffer);
DBUG_RETURN(1); DBUG_RETURN(1);

2
sql/sql_select.h
View file

@ -1945,7 +1945,7 @@ int opt_sum_query(THD* thd,
List<TABLE_LIST> &tables, List<Item> &all_fields, COND *conds); List<TABLE_LIST> &tables, List<Item> &all_fields, COND *conds);
/* from sql_delete.cc, used by opt_range.cc */ /* from sql_delete.cc, used by opt_range.cc */
extern "C" int refpos_order_cmp(void* arg, const void *a,const void *b); extern "C" int refpos_order_cmp(void *arg, const void *a,const void *b);
/** class to copying an field/item to a key struct */ /** class to copying an field/item to a key struct */

6
sql/sql_sort.h
View file

@ -18,7 +18,7 @@
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
#include "my_base.h" /* ha_rows */ #include "my_base.h" /* ha_rows */
#include <my_sys.h> /* qsort2_cmp */ #include <my_cmp.h>
#include "queues.h" #include "queues.h"
#include "sql_string.h" #include "sql_string.h"
#include "sql_class.h" #include "sql_class.h"
@ -565,7 +565,7 @@ public:
bool not_killable; bool not_killable;
String tmp_buffer; String tmp_buffer;
// The fields below are used only by Unique class. // The fields below are used only by Unique class.
qsort2_cmp compare; qsort_cmp2 compare;
BUFFPEK_COMPARE_CONTEXT cmp_context; BUFFPEK_COMPARE_CONTEXT cmp_context;
Sort_param() Sort_param()
@ -669,7 +669,7 @@ public:
void try_to_pack_sortkeys(); void try_to_pack_sortkeys();
qsort2_cmp get_compare_function() const qsort_cmp2 get_compare_function() const
{ {
return using_packed_sortkeys() ? return using_packed_sortkeys() ?
get_packed_keys_compare_ptr() : get_packed_keys_compare_ptr() :

15
sql/sql_statistics.cc
View file

@ -1646,8 +1646,8 @@ public:
table_field= field; table_field= field;
tree_key_length= field->pack_length(); tree_key_length= field->pack_length();
tree= new Unique((qsort_cmp2) simple_str_key_cmp, (void*) field, tree= new Unique(simple_str_key_cmp, field, tree_key_length,
tree_key_length, max_heap_table_size, 1); max_heap_table_size, 1);
} }
virtual ~Count_distinct_field() virtual ~Count_distinct_field()
@ -1732,13 +1732,13 @@ public:
static static
int simple_ulonglong_key_cmp(void* arg, uchar* key1, uchar* key2) int simple_ulonglong_key_cmp(void*, const void* key1, const void* key2)
{ {
ulonglong *val1= (ulonglong *) key1; const ulonglong *val1= static_cast<const ulonglong *>(key1);
ulonglong *val2= (ulonglong *) key2; const ulonglong *val2= static_cast<const ulonglong *>(key2);
return *val1 > *val2 ? 1 : *val1 == *val2 ? 0 : -1; return *val1 > *val2 ? 1 : *val1 == *val2 ? 0 : -1;
} }
/* /*
The class Count_distinct_field_bit is derived from the class The class Count_distinct_field_bit is derived from the class
@ -1755,8 +1755,7 @@ public:
table_field= field; table_field= field;
tree_key_length= sizeof(ulonglong); tree_key_length= sizeof(ulonglong);
tree= new Unique((qsort_cmp2) simple_ulonglong_key_cmp, tree= new Unique(simple_ulonglong_key_cmp, &tree_key_length,
(void*) &tree_key_length,
tree_key_length, max_heap_table_size, 1); tree_key_length, max_heap_table_size, 1);
} }

8
sql/sql_table.cc
View file

@ -2957,8 +2957,10 @@ bool quick_rm_table(THD *thd, handlerton *base, const LEX_CSTRING *db,
PRIMARY keys are prioritized. PRIMARY keys are prioritized.
*/ */
static int sort_keys(KEY *a, KEY *b) static int sort_keys(const void *a_, const void *b_)
{ {
const KEY *a= static_cast<const KEY *>(a_);
const KEY *b= static_cast<const KEY *>(b_);
ulong a_flags= a->flags, b_flags= b->flags; ulong a_flags= a->flags, b_flags= b->flags;
/* /*
@ -7143,8 +7145,10 @@ static bool fix_constraints_names(THD *thd, List<Virtual_column_info>
} }
static int compare_uint(const uint *s, const uint *t) static int compare_uint(const void *s_, const void *t_)
{ {
const uint *s= static_cast<const uint *>(s_);
const uint *t= static_cast<const uint *>(t_);
return (*s < *t) ? -1 : ((*s > *t) ? 1 : 0); return (*s < *t) ? -1 : ((*s > *t) ? 1 : 0);
} }

10
sql/sql_type.cc
View file

@ -5844,9 +5844,9 @@ cmp_item *Type_handler_timestamp_common::make_cmp_item(THD *thd,
/***************************************************************************/ /***************************************************************************/
static int srtcmp_in(const void *cs_, const void *x_, const void *y_) static int srtcmp_in(void *cs_, const void *x_, const void *y_)
{ {
const CHARSET_INFO *cs= static_cast<const CHARSET_INFO *>(cs_); CHARSET_INFO *cs= static_cast<CHARSET_INFO *>(cs_);
const String *x= static_cast<const String *>(x_); const String *x= static_cast<const String *>(x_);
const String *y= static_cast<const String *>(y_); const String *y= static_cast<const String *>(y_);
return cs->strnncollsp(x->ptr(), x->length(), y->ptr(), y->length()); return cs->strnncollsp(x->ptr(), x->length(), y->ptr(), y->length());
@ -5856,12 +5856,10 @@ in_vector *Type_handler_string_result::make_in_vector(THD *thd,
const Item_func_in *func, const Item_func_in *func,
uint nargs) const uint nargs) const
{ {
return new (thd->mem_root) in_string(thd, nargs, (qsort2_cmp) srtcmp_in, return new (thd->mem_root)
func->compare_collation()); in_string(thd, nargs, srtcmp_in, func->compare_collation());
} }
in_vector *Type_handler_int_result::make_in_vector(THD *thd, in_vector *Type_handler_int_result::make_in_vector(THD *thd,
const Item_func_in *func, const Item_func_in *func,
uint nargs) const uint nargs) const

10
sql/uniques.cc
View file

@ -429,11 +429,13 @@ Unique::reset()
C_MODE_START C_MODE_START
static int buffpek_compare(void *arg, uchar *key_ptr1, uchar *key_ptr2) static int buffpek_compare(void *arg, const void *key_ptr1,
const void *key_ptr2)
{ {
BUFFPEK_COMPARE_CONTEXT *ctx= (BUFFPEK_COMPARE_CONTEXT *) arg; auto ctx= static_cast<const BUFFPEK_COMPARE_CONTEXT *>(arg);
return ctx->key_compare(ctx->key_compare_arg, return ctx->key_compare(ctx->key_compare_arg,
*((uchar **) key_ptr1), *((uchar **)key_ptr2)); *(static_cast<const uchar *const *>(key_ptr1)),
*(static_cast<const uchar *const *>(key_ptr2)));
} }
C_MODE_END C_MODE_END
@ -734,7 +736,7 @@ bool Unique::merge(TABLE *table, uchar *buff, size_t buff_size,
sort_param.unique_buff= buff +(sort_param.max_keys_per_buffer * sort_param.unique_buff= buff +(sort_param.max_keys_per_buffer *
sort_param.sort_length); sort_param.sort_length);
sort_param.compare= (qsort2_cmp) buffpek_compare; sort_param.compare= buffpek_compare;
sort_param.cmp_context.key_compare= tree.compare; sort_param.cmp_context.key_compare= tree.compare;
sort_param.cmp_context.key_compare_arg= tree.custom_arg; sort_param.cmp_context.key_compare_arg= tree.custom_arg;

4
storage/csv/ha_tina.cc
View file

@ -96,8 +96,10 @@ static handler *tina_create_handler(handlerton *hton,
/* /*
Used for sorting chains with qsort(). Used for sorting chains with qsort().
*/ */
int sort_set (tina_set *a, tina_set *b) int sort_set (const void *a_, const void *b_)
{ {
const tina_set *a= static_cast<const tina_set*>(a_);
const tina_set *b= static_cast<const tina_set*>(b_);
/* /*
We assume that intervals do not intersect. So, it is enought to compare We assume that intervals do not intersect. So, it is enought to compare
any two points. Here we take start of intervals for comparison. any two points. Here we take start of intervals for comparison.

14
storage/heap/hp_create.c
View file

@ -16,7 +16,7 @@
#include "heapdef.h" #include "heapdef.h"
static int keys_compare(heap_rb_param *param, uchar *key1, uchar *key2); static int keys_compare(void *heap_rb, const void *key1, const void *key2);
static void init_block(HP_BLOCK *block,uint reclength,ulong min_records, static void init_block(HP_BLOCK *block,uint reclength,ulong min_records,
ulong max_records); ulong max_records);
@ -190,7 +190,7 @@ int heap_create(const char *name, HP_CREATE_INFO *create_info,
keyseg++; keyseg++;
init_tree(&keyinfo->rb_tree, 0, 0, sizeof(uchar*), init_tree(&keyinfo->rb_tree, 0, 0, sizeof(uchar*),
(qsort_cmp2)keys_compare, NULL, NULL, keys_compare, NULL, NULL,
MYF((create_info->internal_table ? MY_THREAD_SPECIFIC : 0) | MYF((create_info->internal_table ? MY_THREAD_SPECIFIC : 0) |
MY_TREE_WITH_DELETE)); MY_TREE_WITH_DELETE));
keyinfo->delete_key= hp_rb_delete_key; keyinfo->delete_key= hp_rb_delete_key;
@ -255,11 +255,15 @@ err:
} /* heap_create */ } /* heap_create */
static int keys_compare(heap_rb_param *param, uchar *key1, uchar *key2) static int keys_compare(void *heap_rb_, const void *key1_,
const void *key2_)
{ {
heap_rb_param *heap_rb= heap_rb_;
const uchar *key1= key1_;
const uchar *key2= key2_;
uint not_used[2]; uint not_used[2];
return ha_key_cmp(param->keyseg, key1, key2, param->key_length, return ha_key_cmp(heap_rb->keyseg, key1, key2, heap_rb->key_length,
param->search_flag, not_used); heap_rb->search_flag, not_used);
} }
static void init_block(HP_BLOCK *block, uint reclength, ulong min_records, static void init_block(HP_BLOCK *block, uint reclength, ulong min_records,

31
storage/maria/aria_pack.c
View file

@ -135,8 +135,8 @@ static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees,
uint trees, uint trees,
HUFF_COUNTS *huff_counts, HUFF_COUNTS *huff_counts,
uint fields); uint fields);
static int compare_tree(void* cmp_arg __attribute__((unused)), static int compare_tree(void *cmp_arg __attribute__((unused)),
const uchar *s,const uchar *t); const void *s, const void *t);
static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts); static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts);
static void check_counts(HUFF_COUNTS *huff_counts,uint trees, static void check_counts(HUFF_COUNTS *huff_counts,uint trees,
my_off_t records); my_off_t records);
@ -146,7 +146,8 @@ static int test_space_compress(HUFF_COUNTS *huff_counts,my_off_t records,
enum en_fieldtype field_type); enum en_fieldtype field_type);
static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees); static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees);
static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts); static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts);
static int compare_huff_elements(void *not_used, uchar *a,uchar *b); static int compare_huff_elements(void *not_used, const void *a,
const void *b);
static int save_counts_in_queue(uchar *key,element_count count, static int save_counts_in_queue(uchar *key,element_count count,
HUFF_TREE *tree); HUFF_TREE *tree);
static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag); static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag);
@ -180,7 +181,7 @@ static int mrg_rrnd(PACK_MRG_INFO *info,uchar *buf);
static void mrg_reset(PACK_MRG_INFO *mrg); static void mrg_reset(PACK_MRG_INFO *mrg);
#if !defined(DBUG_OFF) #if !defined(DBUG_OFF)
static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count); static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count);
static int fakecmp(my_off_t **count1, my_off_t **count2); static int fakecmp(const void *count1, const void *count2);
#endif #endif
/* /*
@ -905,8 +906,8 @@ static HUFF_COUNTS *init_huff_count(MARIA_HA *info,my_off_t records)
'tree_pos'. It's keys are implemented by pointers into 'tree_buff'. 'tree_pos'. It's keys are implemented by pointers into 'tree_buff'.
This is accomplished by '-1' as the element size. This is accomplished by '-1' as the element size.
*/ */
init_tree(&count[col_nr].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL, init_tree(&count[col_nr].int_tree, 0, 0, -1, compare_tree, NULL, NULL,
NULL, MYF(0)); MYF(0));
if (records && type != FIELD_BLOB && type != FIELD_VARCHAR) if (records && type != FIELD_BLOB && type != FIELD_VARCHAR)
count[col_nr].tree_pos=count[col_nr].tree_buff = count[col_nr].tree_pos=count[col_nr].tree_buff =
my_malloc(PSI_NOT_INSTRUMENTED, my_malloc(PSI_NOT_INSTRUMENTED,
@ -1258,12 +1259,14 @@ static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
} }
static int compare_huff_elements(void *not_used __attribute__((unused)), static int compare_huff_elements(void *not_used __attribute__((unused)),
uchar *a, uchar *b) const void *a_, const void *b_)
{ {
return *((my_off_t*) a) < *((my_off_t*) b) ? -1 : const my_off_t *a= a_;
(*((my_off_t*) a) == *((my_off_t*) b) ? 0 : 1); const my_off_t *b= b_;
return *a < *b ? -1 : (*a == *b ? 0 : 1);
} }
/* Check each tree if we should use pre-space-compress, end-space- /* Check each tree if we should use pre-space-compress, end-space-
compress, empty-field-compress or zero-field-compress */ compress, empty-field-compress or zero-field-compress */
@ -1770,9 +1773,11 @@ static int make_huff_tree(HUFF_TREE *huff_tree, HUFF_COUNTS *huff_counts)
return 0; return 0;
} }
static int compare_tree(void* cmp_arg __attribute__((unused)), static int compare_tree(void *cmp_arg __attribute__((unused)), const void *s_,
register const uchar *s, register const uchar *t) const void *t_)
{ {
const uchar *s= s_;
const uchar *t= t_;
uint length; uint length;
for (length=global_count->field_length; length-- ;) for (length=global_count->field_length; length-- ;)
if (*s++ != *t++) if (*s++ != *t++)
@ -3323,8 +3328,10 @@ static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count)
-1 count1 > count2 -1 count1 > count2
*/ */
static int fakecmp(my_off_t **count1, my_off_t **count2) static int fakecmp(const void *count1_, const void *count2_)
{ {
const my_off_t *const *count1= count1_;
const my_off_t *const *count2= count2_;
return ((**count1 < **count2) ? 1 : return ((**count1 < **count2) ? 1 :
(**count1 > **count2) ? -1 : 0); (**count1 > **count2) ? -1 : 0);
} }

7
storage/maria/ma_check.c
View file

@ -67,8 +67,7 @@ static int sort_one_index(HA_CHECK *param, MARIA_HA *info,
static int sort_key_read(MARIA_SORT_PARAM *sort_param, uchar *key); static int sort_key_read(MARIA_SORT_PARAM *sort_param, uchar *key);
static int sort_maria_ft_key_read(MARIA_SORT_PARAM *sort_param, uchar *key); static int sort_maria_ft_key_read(MARIA_SORT_PARAM *sort_param, uchar *key);
static int sort_get_next_record(MARIA_SORT_PARAM *sort_param); static int sort_get_next_record(MARIA_SORT_PARAM *sort_param);
static int sort_key_cmp(MARIA_SORT_PARAM *sort_param, const void *a, static int sort_key_cmp(void *sort_param, const void *a, const void *b);
const void *b);
static int sort_maria_ft_key_write(MARIA_SORT_PARAM *sort_param, static int sort_maria_ft_key_write(MARIA_SORT_PARAM *sort_param,
const uchar *a); const uchar *a);
static int sort_key_write(MARIA_SORT_PARAM *sort_param, const uchar *a); static int sort_key_write(MARIA_SORT_PARAM *sort_param, const uchar *a);
@ -5624,9 +5623,9 @@ int _ma_sort_write_record(MARIA_SORT_PARAM *sort_param)
/* Compare two keys from _ma_create_index_by_sort */ /* Compare two keys from _ma_create_index_by_sort */
static int sort_key_cmp(MARIA_SORT_PARAM *sort_param, const void *a, static int sort_key_cmp(void *sort_param_, const void *a, const void *b)
const void *b)
{ {
const MARIA_SORT_PARAM *sort_param= sort_param_;
uint not_used[2]; uint not_used[2];
return (ha_key_cmp(sort_param->seg, *((uchar* const *) a), return (ha_key_cmp(sort_param->seg, *((uchar* const *) a),
*((uchar* const *) b), *((uchar* const *) b),

8
storage/maria/ma_create.c
View file

@ -31,7 +31,7 @@
#endif #endif
#include <m_ctype.h> #include <m_ctype.h>
static int compare_columns(MARIA_COLUMNDEF **a, MARIA_COLUMNDEF **b); static int compare_columns(const void *a, const void *b);
static ulonglong update_tot_length(ulonglong tot_length, ulonglong max_rows, uint length) static ulonglong update_tot_length(ulonglong tot_length, ulonglong max_rows, uint length)
@ -1335,9 +1335,11 @@ static inline int sign(long a)
} }
static int compare_columns(MARIA_COLUMNDEF **a_ptr, MARIA_COLUMNDEF **b_ptr) static int compare_columns(const void *a_ptr_, const void *b_ptr_)
{ {
MARIA_COLUMNDEF *a= *a_ptr, *b= *b_ptr; const MARIA_COLUMNDEF *const *a_ptr= a_ptr_;
const MARIA_COLUMNDEF *const *b_ptr= b_ptr_;
const MARIA_COLUMNDEF *a= *a_ptr, *b= *b_ptr;
enum en_fieldtype a_type, b_type; enum en_fieldtype a_type, b_type;
a_type= (a->type == FIELD_CHECK) ? FIELD_NORMAL : a->type; a_type= (a->type == FIELD_CHECK) ? FIELD_NORMAL : a->type;

27
storage/maria/ma_ft_boolean_search.c
View file

@ -144,9 +144,12 @@ typedef struct st_ft_info
enum { UNINITIALIZED, READY, INDEX_SEARCH, INDEX_DONE } state; enum { UNINITIALIZED, READY, INDEX_SEARCH, INDEX_DONE } state;
} FTB; } FTB;
static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b) static int FTB_WORD_cmp(void *v_, const void *a_, const void *b_)
{ {
int i; int i;
const my_off_t *v= v_;
const FTB_WORD *a= a_;
const FTB_WORD *b= b_;
/* if a==curdoc, take it as a < b */ /* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v) if (v && a->docid[0] == *v)
@ -159,11 +162,15 @@ static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
return i; return i;
} }
static int FTB_WORD_cmp_list(CHARSET_INFO *cs, FTB_WORD **a, FTB_WORD **b) static int FTB_WORD_cmp_list(void *cs_, const void *a_, const void *b_)
{ {
CHARSET_INFO *cs= cs_;
const FTB_WORD *const *a= a_;
const FTB_WORD *const *b= b_;
/* ORDER BY word, ndepth */ /* ORDER BY word, ndepth */
int i= ha_compare_word(cs, (uchar*) (*a)->word + 1, (*a)->len - 1, int i= ha_compare_word(cs, (*a)->word + 1, (*a)->len - 1, (*b)->word + 1,
(uchar*) (*b)->word + 1, (*b)->len - 1); (*b)->len - 1);
if (!i) if (!i)
i=CMP_NUM((*a)->ndepth, (*b)->ndepth); i=CMP_NUM((*a)->ndepth, (*b)->ndepth);
return i; return i;
@ -325,10 +332,12 @@ static int _ftb_parse_query(FTB *ftb, uchar *query, uint len,
} }
static int _ftb_no_dupes_cmp(void* not_used __attribute__((unused)), static int _ftb_no_dupes_cmp(void *not_used __attribute__((unused)),
const void *a,const void *b) const void *a_, const void *b_)
{ {
return CMP_NUM((*((my_off_t*)a)), (*((my_off_t*)b))); const my_off_t *a= a_;
const my_off_t *b= b_;
return CMP_NUM((*a), (*b));
} }
@ -597,14 +606,14 @@ FT_INFO * maria_ft_init_boolean_search(MARIA_HA *info, uint keynr,
sizeof(void *)))) sizeof(void *))))
goto err; goto err;
reinit_queue(&ftb->queue, ftb->queue.max_elements, 0, 0, reinit_queue(&ftb->queue, ftb->queue.max_elements, 0, 0,
(int (*)(void*, uchar*, uchar*))FTB_WORD_cmp, 0, 0, 0); FTB_WORD_cmp, 0, 0, 0);
for (ftbw= ftb->last_word; ftbw; ftbw= ftbw->prev) for (ftbw= ftb->last_word; ftbw; ftbw= ftbw->prev)
queue_insert(&ftb->queue, (uchar *)ftbw); queue_insert(&ftb->queue, (uchar *)ftbw);
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);
my_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, (void*) ftb->charset); FTB_WORD_cmp_list, (void*) 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;

20
storage/maria/ma_ft_nlq_search.c
View file

@ -52,9 +52,11 @@ typedef struct st_ft_superdoc
} FT_SUPERDOC; } FT_SUPERDOC;
static int FT_SUPERDOC_cmp(void* cmp_arg __attribute__((unused)), static int FT_SUPERDOC_cmp(void *cmp_arg __attribute__((unused)),
FT_SUPERDOC *p1, FT_SUPERDOC *p2) const void *p1_, const void *p2_)
{ {
const FT_SUPERDOC *p1= p1_;
const FT_SUPERDOC *p2= p2_;
if (p1->doc.dpos < p2->doc.dpos) if (p1->doc.dpos < p2->doc.dpos)
return -1; return -1;
if (p1->doc.dpos == p2->doc.dpos) if (p1->doc.dpos == p2->doc.dpos)
@ -209,8 +211,10 @@ static int walk_and_push(FT_SUPERDOC *from,
static int FT_DOC_cmp(void *unused __attribute__((unused)), static int FT_DOC_cmp(void *unused __attribute__((unused)),
FT_DOC *a, FT_DOC *b) const void *a_, const void *b_)
{ {
const FT_DOC *a= a_;
const FT_DOC *b= b_;
return CMP_NUM(b->weight, a->weight); return CMP_NUM(b->weight, a->weight);
} }
@ -244,8 +248,8 @@ FT_INFO *maria_ft_init_nlq_search(MARIA_HA *info, uint keynr, uchar *query,
bzero(&wtree,sizeof(wtree)); bzero(&wtree,sizeof(wtree));
init_tree(&aio.dtree,0,0,sizeof(FT_SUPERDOC),(qsort_cmp2)&FT_SUPERDOC_cmp, init_tree(&aio.dtree, 0, 0, sizeof(FT_SUPERDOC), &FT_SUPERDOC_cmp, NULL,
NULL, NULL, MYF(0)); NULL, MYF(0));
maria_ft_parse_init(&wtree, aio.charset); maria_ft_parse_init(&wtree, aio.charset);
ftparser_param->flags= 0; ftparser_param->flags= 0;
@ -260,8 +264,7 @@ FT_INFO *maria_ft_init_nlq_search(MARIA_HA *info, uint keynr, uchar *query,
if (flags & FT_EXPAND && ft_query_expansion_limit) if (flags & FT_EXPAND && ft_query_expansion_limit)
{ {
QUEUE best; QUEUE best;
init_queue(&best,ft_query_expansion_limit,0,0, (queue_compare) &FT_DOC_cmp, init_queue(&best, ft_query_expansion_limit, 0, 0, &FT_DOC_cmp, 0, 0, 0);
0, 0, 0);
tree_walk(&aio.dtree, (tree_walk_action) &walk_and_push, tree_walk(&aio.dtree, (tree_walk_action) &walk_and_push,
&best, left_root_right); &best, left_root_right);
while (best.elements) while (best.elements)
@ -308,8 +311,7 @@ FT_INFO *maria_ft_init_nlq_search(MARIA_HA *info, uint keynr, uchar *query,
&dptr, left_root_right); &dptr, left_root_right);
if (flags & FT_SORTED) if (flags & FT_SORTED)
my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), &FT_DOC_cmp, 0);
(qsort2_cmp)&FT_DOC_cmp, 0);
err: err:
delete_tree(&aio.dtree, 0); delete_tree(&aio.dtree, 0);

12
storage/maria/ma_ft_parser.c
View file

@ -32,10 +32,12 @@ typedef struct st_my_maria_ft_parser_param
} MY_FT_PARSER_PARAM; } MY_FT_PARSER_PARAM;
static int FT_WORD_cmp(CHARSET_INFO* cs, FT_WORD *w1, FT_WORD *w2) static int FT_WORD_cmp(void *cs_, const void *w1_, const void *w2_)
{ {
return ha_compare_word(cs, (uchar*) w1->pos, w1->len, CHARSET_INFO *cs= cs_;
(uchar*) w2->pos, w2->len); const FT_WORD *w1= w1_;
const FT_WORD *w2= w2_;
return ha_compare_word(cs, w1->pos, w1->len, w2->pos, w2->len);
} }
static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat) static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat)
@ -255,8 +257,8 @@ void maria_ft_parse_init(TREE *wtree, CHARSET_INFO *cs)
{ {
DBUG_ENTER("maria_ft_parse_init"); DBUG_ENTER("maria_ft_parse_init");
if (!is_tree_inited(wtree)) if (!is_tree_inited(wtree))
init_tree(wtree,0,0,sizeof(FT_WORD),(qsort_cmp2)&FT_WORD_cmp, NULL, init_tree(wtree, 0, 0, sizeof(FT_WORD), &FT_WORD_cmp, NULL, (void *) cs,
(void*) cs, MYF(0)); MYF(0));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

4
storage/maria/ma_pagecache.c
View file

@ -4722,8 +4722,10 @@ static my_bool free_block(PAGECACHE *pagecache, PAGECACHE_BLOCK_LINK *block,
} }
static int cmp_sec_link(PAGECACHE_BLOCK_LINK **a, PAGECACHE_BLOCK_LINK **b) static int cmp_sec_link(const void *a_, const void *b_)
{ {
PAGECACHE_BLOCK_LINK *const *a= a_;
PAGECACHE_BLOCK_LINK *const *b= b_;
return (((*a)->hash_link->pageno < (*b)->hash_link->pageno) ? -1 : return (((*a)->hash_link->pageno < (*b)->hash_link->pageno) ? -1 :
((*a)->hash_link->pageno > (*b)->hash_link->pageno) ? 1 : 0); ((*a)->hash_link->pageno > (*b)->hash_link->pageno) ? 1 : 0);
} }

16
storage/maria/ma_sort.c
View file

@ -752,8 +752,8 @@ static int write_keys(MARIA_SORT_PARAM *info, register uchar **sort_keys,
if (!buffpek) if (!buffpek)
DBUG_RETURN(1); /* Out of memory */ DBUG_RETURN(1); /* Out of memory */
my_qsort2((uchar*) sort_keys,(size_t) count, sizeof(uchar*), my_qsort2(sort_keys, count, sizeof(uchar*),
(qsort2_cmp) info->key_cmp, info); info->key_cmp, 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))
@ -798,8 +798,8 @@ static int write_keys_varlen(MARIA_SORT_PARAM *info,
if (!buffpek) if (!buffpek)
DBUG_RETURN(1); /* Out of memory */ DBUG_RETURN(1); /* Out of memory */
my_qsort2((uchar*) sort_keys, (size_t) count, sizeof(uchar*), my_qsort2(sort_keys, count, sizeof(uchar*),
(qsort2_cmp) info->key_cmp, info); info->key_cmp, 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))
@ -841,8 +841,8 @@ static int write_index(MARIA_SORT_PARAM *info, register uchar **sort_keys,
{ {
DBUG_ENTER("write_index"); DBUG_ENTER("write_index");
my_qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*), my_qsort2(sort_keys, count,sizeof(uchar*),
(qsort2_cmp) info->key_cmp,info); info->key_cmp,info);
while (count--) while (count--)
{ {
if ((*info->key_write)(info, *sort_keys++)) if ((*info->key_write)(info, *sort_keys++))
@ -1044,8 +1044,8 @@ merge_buffers(MARIA_SORT_PARAM *info, ha_keys keys, IO_CACHE *from_file,
sort_length=info->key_length; sort_length=info->key_length;
if (init_queue(&queue,(uint) (Tb-Fb)+1,offsetof(BUFFPEK,key),0, if (init_queue(&queue,(uint) (Tb-Fb)+1,offsetof(BUFFPEK,key),0,
(int (*)(void*, uchar *,uchar*)) info->key_cmp, info->key_cmp,
(void*) info, 0, 0)) info, 0, 0))
DBUG_RETURN(1); /* purecov: inspected */ DBUG_RETURN(1); /* purecov: inspected */
for (buffpek= Fb ; buffpek <= Tb ; buffpek++) for (buffpek= Fb ; buffpek <= Tb ; buffpek++)

8
storage/maria/ma_write.c
View file

@ -1687,8 +1687,12 @@ static my_bool _ma_ck_write_tree(register MARIA_HA *info, MARIA_KEY *key)
/* typeof(_ma_keys_compare)=qsort_cmp2 */ /* typeof(_ma_keys_compare)=qsort_cmp2 */
static int keys_compare(bulk_insert_param *param, uchar *key1, uchar *key2) static int keys_compare(void *param_, const void *key1_,
const void *key2_)
{ {
const bulk_insert_param *param= param_;
const uchar *key1= key1_;
const uchar *key2= key2_;
uint not_used[2]; uint not_used[2];
return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg, return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg,
key1, key2, USE_WHOLE_KEY, SEARCH_SAME, key1, key2, USE_WHOLE_KEY, SEARCH_SAME,
@ -1794,7 +1798,7 @@ int maria_init_bulk_insert(MARIA_HA *info, size_t cache_size, ha_rows rows)
init_tree(&info->bulk_insert[i], init_tree(&info->bulk_insert[i],
cache_size * key[i].maxlength, cache_size * key[i].maxlength,
cache_size * key[i].maxlength, 0, cache_size * key[i].maxlength, 0,
(qsort_cmp2) keys_compare, keys_free, (void *)params++, MYF(0)); keys_compare, keys_free, params++, MYF(0));
} }
else else
info->bulk_insert[i].root=0; info->bulk_insert[i].root=0;

2
storage/maria/maria_def.h
View file

@ -398,7 +398,7 @@ typedef struct st_maria_sort_param
my_bool calc_checksum; /* calculate table checksum */ my_bool calc_checksum; /* calculate table checksum */
size_t rec_buff_size; size_t rec_buff_size;
int (*key_cmp)(struct st_maria_sort_param *, const void *, const void *); int (*key_cmp)(void *, const void *, const void *);
int (*key_read)(struct st_maria_sort_param *, uchar *); int (*key_read)(struct st_maria_sort_param *, uchar *);
int (*key_write)(struct st_maria_sort_param *, const uchar *); int (*key_write)(struct st_maria_sort_param *, const uchar *);
void (*lock_in_memory)(HA_CHECK *); void (*lock_in_memory)(HA_CHECK *);

22
storage/myisam/ft_boolean_search.c
View file

@ -144,9 +144,12 @@ typedef struct st_ft_info
enum { UNINITIALIZED, READY, INDEX_SEARCH, INDEX_DONE } state; enum { UNINITIALIZED, READY, INDEX_SEARCH, INDEX_DONE } state;
} FTB; } FTB;
static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b) static int FTB_WORD_cmp(void *v_, const void *a_, const void *b_)
{ {
int i; int i;
const my_off_t *v= v_;
const FTB_WORD *a= a_;
const FTB_WORD *b= b_;
/* if a==curdoc, take it as a < b */ /* if a==curdoc, take it as a < b */
if (v && a->docid[0] == *v) if (v && a->docid[0] == *v)
@ -159,11 +162,14 @@ static int FTB_WORD_cmp(my_off_t *v, FTB_WORD *a, FTB_WORD *b)
return i; return i;
} }
static int FTB_WORD_cmp_list(CHARSET_INFO *cs, FTB_WORD **a, FTB_WORD **b) static int FTB_WORD_cmp_list(void *cs_, const void *a_, const void *b_)
{ {
CHARSET_INFO *cs= cs_;
const FTB_WORD *const *a= a_;
const FTB_WORD *const *b= b_;
/* ORDER BY word, ndepth */ /* ORDER BY word, ndepth */
int i= ha_compare_word(cs, (uchar*) (*a)->word + 1, (*a)->len - 1, int i= ha_compare_word(cs, (*a)->word + 1, (*a)->len - 1, (*b)->word + 1,
(uchar*) (*b)->word + 1, (*b)->len - 1); (*b)->len - 1);
if (!i) if (!i)
i= CMP_NUM((*a)->ndepth, (*b)->ndepth); i= CMP_NUM((*a)->ndepth, (*b)->ndepth);
return i; return i;
@ -327,8 +333,8 @@ static int _ftb_parse_query(FTB *ftb, uchar *query, uint len,
} }
static int _ftb_no_dupes_cmp(void* not_used __attribute__((unused)), static int _ftb_no_dupes_cmp(void *not_used __attribute__((unused)),
const void *a,const void *b) const void *a, const void *b)
{ {
return CMP_NUM((*((my_off_t*)a)), (*((my_off_t*)b))); return CMP_NUM((*((my_off_t*)a)), (*((my_off_t*)b)));
} }
@ -607,14 +613,14 @@ FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, uchar *query,
sizeof(void *)))) sizeof(void *))))
goto err; goto err;
reinit_queue(&ftb->queue, ftb->queue.max_elements, 0, 0, reinit_queue(&ftb->queue, ftb->queue.max_elements, 0, 0,
(int (*)(void*, uchar*, uchar*))FTB_WORD_cmp, 0, 0, 0); FTB_WORD_cmp, 0, 0, 0);
for (ftbw= ftb->last_word; ftbw; ftbw= ftbw->prev) for (ftbw= ftb->last_word; ftbw; ftbw= ftbw->prev)
queue_insert(&ftb->queue, (uchar *)ftbw); queue_insert(&ftb->queue, (uchar *)ftbw);
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, &queue_top(&ftb->queue), sizeof(FTB_WORD *)*ftb->queue.elements); memcpy(ftb->list, &queue_top(&ftb->queue), sizeof(FTB_WORD *)*ftb->queue.elements);
my_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, (void*)ftb->charset); FTB_WORD_cmp_list, (void*)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;

17
storage/myisam/ft_nlq_search.c
View file

@ -51,9 +51,10 @@ typedef struct st_ft_superdoc
double tmp_weight; double tmp_weight;
} FT_SUPERDOC; } FT_SUPERDOC;
static int FT_SUPERDOC_cmp(void* cmp_arg __attribute__((unused)), static int FT_SUPERDOC_cmp(void *cmp_arg __attribute__((unused)),
FT_SUPERDOC *p1, FT_SUPERDOC *p2) const void *p1_, const void *p2_)
{ {
const FT_SUPERDOC *p1= p1_, *p2= p2_;
if (p1->doc.dpos < p2->doc.dpos) if (p1->doc.dpos < p2->doc.dpos)
return -1; return -1;
if (p1->doc.dpos == p2->doc.dpos) if (p1->doc.dpos == p2->doc.dpos)
@ -206,9 +207,10 @@ static int walk_and_push(FT_SUPERDOC *from,
} }
static int FT_DOC_cmp(void *unused __attribute__((unused)), static int FT_DOC_cmp(void *unused __attribute__((unused)), const void *a_,
FT_DOC *a, FT_DOC *b) const void *b_)
{ {
const FT_DOC *a= a_, *b= b_;
return CMP_NUM(b->weight, a->weight); return CMP_NUM(b->weight, a->weight);
} }
@ -242,7 +244,7 @@ FT_INFO *ft_init_nlq_search(MI_INFO *info, uint keynr, uchar *query,
bzero(&wtree,sizeof(wtree)); bzero(&wtree,sizeof(wtree));
init_tree(&aio.dtree,0,0,sizeof(FT_SUPERDOC),(qsort_cmp2)&FT_SUPERDOC_cmp, init_tree(&aio.dtree,0,0,sizeof(FT_SUPERDOC),&FT_SUPERDOC_cmp,
NULL, NULL, MYF(0)); NULL, NULL, MYF(0));
ft_parse_init(&wtree, aio.charset); ft_parse_init(&wtree, aio.charset);
@ -258,8 +260,7 @@ FT_INFO *ft_init_nlq_search(MI_INFO *info, uint keynr, uchar *query,
if (flags & FT_EXPAND && ft_query_expansion_limit) if (flags & FT_EXPAND && ft_query_expansion_limit)
{ {
QUEUE best; QUEUE best;
init_queue(&best,ft_query_expansion_limit,0,0, (queue_compare) &FT_DOC_cmp, init_queue(&best, ft_query_expansion_limit, 0, 0, &FT_DOC_cmp, 0, 0, 0);
0, 0, 0);
tree_walk(&aio.dtree, (tree_walk_action) &walk_and_push, tree_walk(&aio.dtree, (tree_walk_action) &walk_and_push,
&best, left_root_right); &best, left_root_right);
while (best.elements) while (best.elements)
@ -306,7 +307,7 @@ 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)
my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), (qsort2_cmp)&FT_DOC_cmp, my_qsort2(dlist->doc, dlist->ndocs, sizeof(FT_DOC), &FT_DOC_cmp,
0); 0);
err: err:

11
storage/myisam/ft_parser.c
View file

@ -30,10 +30,11 @@ typedef struct st_my_ft_parser_param
MEM_ROOT *mem_root; MEM_ROOT *mem_root;
} MY_FT_PARSER_PARAM; } MY_FT_PARSER_PARAM;
static int FT_WORD_cmp(CHARSET_INFO* cs, FT_WORD *w1, FT_WORD *w2) static int FT_WORD_cmp(void *cs_, const void *w1_, const void *w2_)
{ {
return ha_compare_word(cs, (uchar*) w1->pos, w1->len, CHARSET_INFO *cs= cs_;
(uchar*) w2->pos, w2->len); const FT_WORD *w1= w1_, *w2= w2_;
return ha_compare_word(cs, w1->pos, w1->len, w2->pos, w2->len);
} }
static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat) static int walk_and_copy(FT_WORD *word,uint32 count,FT_DOCSTAT *docstat)
@ -257,8 +258,8 @@ void ft_parse_init(TREE *wtree, CHARSET_INFO *cs)
{ {
DBUG_ENTER("ft_parse_init"); DBUG_ENTER("ft_parse_init");
if (!is_tree_inited(wtree)) if (!is_tree_inited(wtree))
init_tree(wtree, 0, 0, sizeof(FT_WORD), (qsort_cmp2)&FT_WORD_cmp, 0, init_tree(wtree, 0, 0, sizeof(FT_WORD), &FT_WORD_cmp, 0, (void *) cs,
(void*)cs, MYF(0)); MYF(0));
DBUG_VOID_RETURN; DBUG_VOID_RETURN;
} }

7
storage/myisam/ft_stopwords.c
View file

@ -30,9 +30,10 @@ typedef struct st_ft_stopwords
static TREE *stopwords3=NULL; static TREE *stopwords3=NULL;
static int FT_STOPWORD_cmp(void* cmp_arg __attribute__((unused)), static int FT_STOPWORD_cmp(void *cmp_arg __attribute__((unused)),
FT_STOPWORD *w1, FT_STOPWORD *w2) const void *w1_, const void *w2_)
{ {
const FT_STOPWORD *w1= w1_, *w2= w2_;
return ha_compare_word(ft_stopword_cs, return ha_compare_word(ft_stopword_cs,
(uchar *) w1->pos, w1->len, (uchar *) w1->pos, w1->len,
(uchar *) w2->pos, w2->len); (uchar *) w2->pos, w2->len);
@ -62,7 +63,7 @@ int ft_init_stopwords()
if (!(stopwords3=(TREE *)my_malloc(mi_key_memory_ft_stopwords, if (!(stopwords3=(TREE *)my_malloc(mi_key_memory_ft_stopwords,
sizeof(TREE), MYF(0)))) sizeof(TREE), MYF(0))))
DBUG_RETURN(-1); DBUG_RETURN(-1);
init_tree(stopwords3,0,0,sizeof(FT_STOPWORD),(qsort_cmp2)&FT_STOPWORD_cmp, init_tree(stopwords3,0,0,sizeof(FT_STOPWORD),&FT_STOPWORD_cmp,
(ft_stopword_file ? (tree_element_free)&FT_STOPWORD_free : 0), (ft_stopword_file ? (tree_element_free)&FT_STOPWORD_free : 0),
NULL, MYF(0)); NULL, MYF(0));
/* /*

12
storage/myisam/mi_check.c
View file

@ -61,7 +61,7 @@ static int sort_one_index(HA_CHECK *, MI_INFO *, MI_KEYDEF *, my_off_t, File);
static int sort_key_read(MI_SORT_PARAM *sort_param,void *key); static int sort_key_read(MI_SORT_PARAM *sort_param,void *key);
static int sort_ft_key_read(MI_SORT_PARAM *sort_param,void *key); static int sort_ft_key_read(MI_SORT_PARAM *sort_param,void *key);
static int sort_get_next_record(MI_SORT_PARAM *sort_param); static int sort_get_next_record(MI_SORT_PARAM *sort_param);
static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,const void *b); static int sort_key_cmp(void *sort_param, const void *a, const void *b);
static int sort_ft_key_write(MI_SORT_PARAM *sort_param, const void *a); static int sort_ft_key_write(MI_SORT_PARAM *sort_param, const void *a);
static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a); static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a);
static my_off_t get_record_for_key(MI_INFO *, MI_KEYDEF *, uchar *); static my_off_t get_record_for_key(MI_INFO *, MI_KEYDEF *, uchar *);
@ -3805,12 +3805,14 @@ 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, static int sort_key_cmp(void *sort_param_, const void *a_, const void *b_)
const void *b)
{ {
const MI_SORT_PARAM *sort_param= sort_param_;
uint not_used[2]; uint not_used[2];
return (ha_key_cmp(sort_param->seg, *((uchar**) a), *((uchar**) b), const void *const *a= a_;
USE_WHOLE_KEY, SEARCH_SAME, not_used)); const void *const *b= b_;
return (ha_key_cmp(sort_param->seg, *a, *b,
USE_WHOLE_KEY, SEARCH_SAME, not_used));
} /* sort_key_cmp */ } /* sort_key_cmp */

7
storage/myisam/mi_write.c
View file

@ -923,8 +923,11 @@ int _mi_ck_write_tree(register MI_INFO *info, uint keynr, uchar *key,
/* typeof(_mi_keys_compare)=qsort_cmp2 */ /* typeof(_mi_keys_compare)=qsort_cmp2 */
static int keys_compare(bulk_insert_param *param, uchar *key1, uchar *key2) static int keys_compare(void *param_, const void *key1_, const void *key2_)
{ {
const bulk_insert_param *param= param_;
const uchar *key1= key1_;
const uchar *key2= key2_;
uint not_used[2]; uint not_used[2];
return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg, return ha_key_cmp(param->info->s->keyinfo[param->keynr].seg,
key1, key2, USE_WHOLE_KEY, SEARCH_SAME, key1, key2, USE_WHOLE_KEY, SEARCH_SAME,
@ -1020,7 +1023,7 @@ int mi_init_bulk_insert(MI_INFO *info, size_t cache_size, ha_rows rows)
init_tree(&info->bulk_insert[i], init_tree(&info->bulk_insert[i],
cache_size * key[i].maxlength, cache_size * key[i].maxlength,
cache_size * key[i].maxlength, 0, cache_size * key[i].maxlength, 0,
(qsort_cmp2)keys_compare, keys_free, (void *)params++, MYF(0)); keys_compare, keys_free, params++, MYF(0));
} }
else else
info->bulk_insert[i].root=0; info->bulk_insert[i].root=0;

8
storage/myisam/myisamlog.c
View file

@ -57,7 +57,7 @@ extern int main(int argc,char * *argv);
static void get_options(int *argc,char ***argv); static void get_options(int *argc,char ***argv);
static int examine_log(char * file_name,char **table_names); static int examine_log(char * file_name,char **table_names);
static int read_string(IO_CACHE *file,uchar* *to,uint length); static int read_string(IO_CACHE *file,uchar* *to,uint length);
static int file_info_compare(void *cmp_arg, void *a,void *b); static int file_info_compare(void *cmp_arg, const void *a, const void *b);
static int test_if_open(struct file_info *key,element_count count, static int test_if_open(struct file_info *key,element_count count,
struct test_if_open_param *param); struct test_if_open_param *param);
static void fix_blob_pointers(MI_INFO *isam,uchar *record); static void fix_blob_pointers(MI_INFO *isam,uchar *record);
@ -329,7 +329,7 @@ static int examine_log(char * file_name, char **table_names)
init_io_cache(&cache,file,0,READ_CACHE,start_offset,0,MYF(0)); init_io_cache(&cache,file,0,READ_CACHE,start_offset,0,MYF(0));
bzero((uchar*) com_count,sizeof(com_count)); bzero((uchar*) com_count,sizeof(com_count));
init_tree(&tree,0,0,sizeof(file_info),(qsort_cmp2) file_info_compare, init_tree(&tree,0,0,sizeof(file_info), file_info_compare,
file_info_free, NULL, MYF(MY_TREE_WITH_DELETE)); file_info_free, NULL, MYF(MY_TREE_WITH_DELETE));
(void) init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE, (void) init_key_cache(dflt_key_cache,KEY_CACHE_BLOCK_SIZE,KEY_CACHE_SIZE,
0, 0, 0, 0); 0, 0, 0, 0);
@ -696,8 +696,8 @@ static int read_string(IO_CACHE *file, register uchar* *to, register uint length
} /* read_string */ } /* read_string */
static int file_info_compare(void* cmp_arg __attribute__((unused)), static int file_info_compare(void *cmp_arg __attribute__((unused)),
void *a, void *b) const void *a, const void *b)
{ {
long lint; long lint;

29
storage/myisam/myisampack.c
View file

@ -131,8 +131,8 @@ static void free_counts_and_tree_and_queue(HUFF_TREE *huff_trees,
uint trees, uint trees,
HUFF_COUNTS *huff_counts, HUFF_COUNTS *huff_counts,
uint fields); uint fields);
static int compare_tree(void* cmp_arg __attribute__((unused)), static int compare_tree(void *cmp_arg __attribute__((unused)),
const uchar *s,const uchar *t); const void *s, const void *t);
static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts); static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts);
static void check_counts(HUFF_COUNTS *huff_counts,uint trees, static void check_counts(HUFF_COUNTS *huff_counts,uint trees,
my_off_t records); my_off_t records);
@ -142,7 +142,7 @@ static int test_space_compress(HUFF_COUNTS *huff_counts,my_off_t records,
enum en_fieldtype field_type); enum en_fieldtype field_type);
static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees); static HUFF_TREE* make_huff_trees(HUFF_COUNTS *huff_counts,uint trees);
static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts); static int make_huff_tree(HUFF_TREE *tree,HUFF_COUNTS *huff_counts);
static int compare_huff_elements(void *not_used, uchar *a,uchar *b); static int compare_huff_elements(void *not_used, const void *a, const void *b);
static int save_counts_in_queue(uchar *key,element_count count, static int save_counts_in_queue(uchar *key,element_count count,
HUFF_TREE *tree); HUFF_TREE *tree);
static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag); static my_off_t calc_packed_length(HUFF_COUNTS *huff_counts,uint flag);
@ -176,7 +176,7 @@ static int mrg_rrnd(PACK_MRG_INFO *info,uchar *buf);
static void mrg_reset(PACK_MRG_INFO *mrg); static void mrg_reset(PACK_MRG_INFO *mrg);
#if !defined(DBUG_OFF) #if !defined(DBUG_OFF)
static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count); static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count);
static int fakecmp(my_off_t **count1, my_off_t **count2); static int fakecmp(const void *count1, const void *count2);
#endif #endif
@ -822,8 +822,8 @@ static HUFF_COUNTS *init_huff_count(MI_INFO *info,my_off_t records)
'tree_pos'. It's keys are implemented by pointers into 'tree_buff'. 'tree_pos'. It's keys are implemented by pointers into 'tree_buff'.
This is accomplished by '-1' as the element size. This is accomplished by '-1' as the element size.
*/ */
init_tree(&count[i].int_tree,0,0,-1,(qsort_cmp2) compare_tree, NULL, init_tree(&count[i].int_tree, 0, 0, -1, compare_tree, NULL, NULL,
NULL, MYF(0)); MYF(0));
if (records && type != FIELD_BLOB && type != FIELD_VARCHAR) if (records && type != FIELD_BLOB && type != FIELD_VARCHAR)
count[i].tree_pos=count[i].tree_buff = count[i].tree_pos=count[i].tree_buff =
my_malloc(PSI_NOT_INSTRUMENTED, count[i].field_length > 1 ? tree_buff_length : 2, my_malloc(PSI_NOT_INSTRUMENTED, count[i].field_length > 1 ? tree_buff_length : 2,
@ -1182,10 +1182,11 @@ static int get_statistic(PACK_MRG_INFO *mrg,HUFF_COUNTS *huff_counts)
} }
static int compare_huff_elements(void *not_used __attribute__((unused)), static int compare_huff_elements(void *not_used __attribute__((unused)),
uchar *a, uchar *b) const void *a_, const void *b_)
{ {
return *((my_off_t*) a) < *((my_off_t*) b) ? -1 : const my_off_t *a= a_;
(*((my_off_t*) a) == *((my_off_t*) b) ? 0 : 1); const my_off_t *b= b_;
return *a < *b ? -1 : (*a == *b ? 0 : 1);
} }
/* Check each tree if we should use pre-space-compress, end-space- /* Check each tree if we should use pre-space-compress, end-space-
@ -1694,9 +1695,11 @@ static int make_huff_tree(HUFF_TREE *huff_tree, HUFF_COUNTS *huff_counts)
return 0; return 0;
} }
static int compare_tree(void* cmp_arg __attribute__((unused)), static int compare_tree(void *cmp_arg __attribute__((unused)), const void *s_,
register const uchar *s, register const uchar *t) const void *t_)
{ {
const uchar *s= s_;
const uchar *t= t_;
uint length; uint length;
for (length=global_count->field_length; length-- ;) for (length=global_count->field_length; length-- ;)
if (*s++ != *t++) if (*s++ != *t++)
@ -3227,8 +3230,10 @@ static void fakebigcodes(HUFF_COUNTS *huff_counts, HUFF_COUNTS *end_count)
-1 count1 > count2 -1 count1 > count2
*/ */
static int fakecmp(my_off_t **count1, my_off_t **count2) static int fakecmp(const void *count1_, const void *count2_)
{ {
const my_off_t *const *count1= count1_;
const my_off_t *const *count2= count2_;
return ((**count1 < **count2) ? 1 : return ((**count1 < **count2) ? 1 :
(**count1 > **count2) ? -1 : 0); (**count1 > **count2) ? -1 : 0);
} }

14
storage/myisam/sort.c
View file

@ -730,8 +730,8 @@ static int write_keys(MI_SORT_PARAM *info, register uchar **sort_keys,
if (!buffpek) if (!buffpek)
DBUG_RETURN(1); /* Out of memory */ DBUG_RETURN(1); /* Out of memory */
my_qsort2((uchar*) sort_keys,(size_t) count, sizeof(uchar*), my_qsort2(sort_keys, count, sizeof(uchar *),
(qsort2_cmp) info->key_cmp, info); info->key_cmp, 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))
@ -776,8 +776,8 @@ static int write_keys_varlen(MI_SORT_PARAM *info,
if (!buffpek) if (!buffpek)
DBUG_RETURN(1); /* Out of memory */ DBUG_RETURN(1); /* Out of memory */
my_qsort2((uchar*) sort_keys, (size_t) count, sizeof(uchar*), my_qsort2(sort_keys, count, sizeof(uchar *),
(qsort2_cmp) info->key_cmp, info); info->key_cmp, 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))
@ -818,8 +818,8 @@ static int write_index(MI_SORT_PARAM *info, register uchar **sort_keys,
{ {
DBUG_ENTER("write_index"); DBUG_ENTER("write_index");
my_qsort2((uchar*) sort_keys,(size_t) count,sizeof(uchar*), my_qsort2(sort_keys, count, sizeof(uchar *),
(qsort2_cmp) info->key_cmp,info); info->key_cmp, info);
while (count--) while (count--)
{ {
if ((*info->key_write)(info,*sort_keys++)) if ((*info->key_write)(info,*sort_keys++))
@ -1004,7 +1004,7 @@ merge_buffers(MI_SORT_PARAM *info, ha_keys keys, IO_CACHE *from_file,
sort_length=info->key_length; sort_length=info->key_length;
if (init_queue(&queue,(uint) (Tb-Fb)+1,offsetof(BUFFPEK,key),0, if (init_queue(&queue,(uint) (Tb-Fb)+1,offsetof(BUFFPEK,key),0,
(int (*)(void*, uchar *,uchar*)) info->key_cmp, info->key_cmp,
(void*) info, 0, 0)) (void*) info, 0, 0))
DBUG_RETURN(1); /* purecov: inspected */ DBUG_RETURN(1); /* purecov: inspected */

6
storage/myisammrg/myrg_queue.c
View file

@ -15,10 +15,10 @@
#include "myrg_def.h" #include "myrg_def.h"
static int queue_key_cmp(void *keyseg, uchar *a, uchar *b) static int queue_key_cmp(void *keyseg, const void *a, const void *b)
{ {
MYRG_TABLE *ma= (MYRG_TABLE *)a; const MYRG_TABLE *ma= a;
MYRG_TABLE *mb= (MYRG_TABLE *)b; const MYRG_TABLE *mb= b;
MI_INFO *aa= ma->table; MI_INFO *aa= ma->table;
MI_INFO *bb= mb->table; MI_INFO *bb= mb->table;
uint not_used[2]; uint not_used[2];

6
storage/spider/spd_table.cc
View file

@ -8069,9 +8069,11 @@ bool spider_check_index_merge(
} }
int spider_compare_for_sort( int spider_compare_for_sort(
SPIDER_SORT *a, const void *a_,
SPIDER_SORT *b const void *b_
) { ) {
const SPIDER_SORT *a= static_cast<const SPIDER_SORT *>(a_);
const SPIDER_SORT *b= static_cast<const SPIDER_SORT *>(b_);
DBUG_ENTER("spider_compare_for_sort"); DBUG_ENTER("spider_compare_for_sort");
if (a->sort > b->sort) if (a->sort > b->sort)
DBUG_RETURN(-1); DBUG_RETURN(-1);

4
storage/spider/spd_table.h
View file

@ -451,8 +451,8 @@ bool spider_check_index_merge(
); );
int spider_compare_for_sort( int spider_compare_for_sort(
SPIDER_SORT *a, const void *a,
SPIDER_SORT *b const void *b
); );
ulong spider_calc_for_sort( ulong spider_calc_for_sort(

4
unittest/mysys/queues-t.c
View file

@ -19,8 +19,10 @@
#include <my_rnd.h> #include <my_rnd.h>
#include "tap.h" #include "tap.h"
int cmp(void *arg __attribute__((unused)), uchar *a, uchar *b) int cmp(void *arg __attribute__((unused)), const void *a_, const void *b_)
{ {
const uchar *a= a_;
const uchar *b= b_;
return *a < *b ? -1 : *a > *b; return *a < *b ? -1 : *a > *b;
} }