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

Fix some -Wsign-conversion

Browse Source 
InnoDB was using int64_t instead of ha_rows (unsigned 64-bit).
This commit is contained in:
Marko Mäkelä 2018-04-29 17:39:48 +03:00
parent baa5a43d8c
commit b2c4740034
13 changed files with 65 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/m_ctype.h
View File

@ -1093,7 +1093,7 @@ my_well_formed_length(CHARSET_INFO *cs, const char *b, const char *e,
MY_STRCOPY_STATUS status; MY_STRCOPY_STATUS status;
(void) cs->cset->well_formed_char_length(cs, b, e, nchars, &status); (void) cs->cset->well_formed_char_length(cs, b, e, nchars, &status);
*error= status.m_well_formed_error_pos == NULL ? 0 : 1; *error= status.m_well_formed_error_pos == NULL ? 0 : 1;
return status.m_source_end_pos - b; return (size_t) (status.m_source_end_pos - b);
} }

14
include/my_sys.h
View File

@ -573,21 +573,21 @@ static inline my_bool my_b_write_byte(IO_CACHE *info, uchar chr)
static inline size_t my_b_fill(IO_CACHE *info) static inline size_t my_b_fill(IO_CACHE *info)
{ {
info->read_pos= info->read_end; info->read_pos= info->read_end;
return _my_b_read(info,0,0) ? 0 : info->read_end - info->read_pos; return _my_b_read(info,0,0) ? 0 : (size_t) (info->read_end - info->read_pos);
} }
static inline my_off_t my_b_tell(const IO_CACHE *info) static inline my_off_t my_b_tell(const IO_CACHE *info)
{ {
if (info->type == WRITE_CACHE) { if (info->type == WRITE_CACHE) {
return info->pos_in_file + (info->write_pos - info->request_pos); return info->pos_in_file + (my_off_t)(info->write_pos - info->request_pos);
} }
return info->pos_in_file + (info->read_pos - info->request_pos); return info->pos_in_file + (my_off_t) (info->read_pos - info->request_pos);
} }
static inline my_off_t my_b_write_tell(const IO_CACHE *info) static inline my_off_t my_b_write_tell(const IO_CACHE *info)
{ {
return info->pos_in_file + (info->write_pos - info->write_buffer); return info->pos_in_file + (my_off_t) (info->write_pos - info->write_buffer);
} }
static inline uchar* my_b_get_buffer_start(const IO_CACHE *info) static inline uchar* my_b_get_buffer_start(const IO_CACHE *info)
@ -597,7 +597,7 @@ static inline uchar* my_b_get_buffer_start(const IO_CACHE *info)
static inline size_t my_b_get_bytes_in_buffer(const IO_CACHE *info) static inline size_t my_b_get_bytes_in_buffer(const IO_CACHE *info)
{ {
return info->read_end - info->request_pos; return (size_t) (info->read_end - info->request_pos);
} }
static inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info) static inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info)
@ -608,9 +608,9 @@ static inline my_off_t my_b_get_pos_in_file(const IO_CACHE *info)
static inline size_t my_b_bytes_in_cache(const IO_CACHE *info) static inline size_t my_b_bytes_in_cache(const IO_CACHE *info)
{ {
if (info->type == WRITE_CACHE) { if (info->type == WRITE_CACHE) {
return info->write_end - info->write_pos; return (size_t) (info->write_end - info->write_pos);
} }
return info->read_end - info->read_pos; return (size_t) (info->read_end - info->read_pos);
} }
int my_b_copy_to_file(IO_CACHE *cache, FILE *file); int my_b_copy_to_file(IO_CACHE *cache, FILE *file);

3
include/my_time.h
View File

@ -104,7 +104,8 @@ typedef struct st_mysql_time_status
static inline void my_time_status_init(MYSQL_TIME_STATUS *status) static inline void my_time_status_init(MYSQL_TIME_STATUS *status)
{ {
status->warnings= status->precision= 0; status->warnings= 0;
status->precision= 0;
} }
my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date, my_bool check_date(const MYSQL_TIME *ltime, my_bool not_zero_date,

2
sql/item.h
View File

@ -4199,7 +4199,7 @@ public:
{ {
// following assert is redundant, because fixed=1 assigned in constructor // following assert is redundant, because fixed=1 assigned in constructor
DBUG_ASSERT(fixed == 1); DBUG_ASSERT(fixed == 1);
ulonglong value= (ulonglong) Item_hex_hybrid::val_int(); longlong value= Item_hex_hybrid::val_int();
int2my_decimal(E_DEC_FATAL_ERROR, value, TRUE, decimal_value); int2my_decimal(E_DEC_FATAL_ERROR, value, TRUE, decimal_value);
return decimal_value; return decimal_value;
} }

15
sql/sql_bitmap.h
View File

@ -141,16 +141,16 @@ public:
}; };
}; };
/* An iterator to quickly walk over bits in unlonglong bitmap. */ /* An iterator to quickly walk over bits in ulonglong bitmap. */
class Table_map_iterator class Table_map_iterator
{ {
ulonglong bmp; ulonglong bmp;
uint no; uint no;
public: public:
Table_map_iterator(ulonglong t) : bmp(t), no(0) {} Table_map_iterator(ulonglong t) : bmp(t), no(0) {}
int next_bit() uint next_bit()
{ {
static const char last_bit[16]= {32, 0, 1, 0, static const uchar last_bit[16]= {32, 0, 1, 0,
2, 0, 1, 0, 2, 0, 1, 0,
3, 0, 1, 0, 3, 0, 1, 0,
2, 0, 1, 0}; 2, 0, 1, 0};
@ -162,10 +162,10 @@ public:
if (!bmp) if (!bmp)
return BITMAP_END; return BITMAP_END;
} }
bmp &= ~(1LL << bit); bmp &= ~(1ULL << bit);
return no + bit; return no + bit;
} }
int operator++(int) { return next_bit(); } uint operator++(int) { return next_bit(); }
enum { BITMAP_END= 64 }; enum { BITMAP_END= 64 };
}; };
@ -201,7 +201,10 @@ public:
bool is_subset(const Bitmap<64>& map2) const { return !(map & ~map2.map); } bool is_subset(const Bitmap<64>& map2) const { return !(map & ~map2.map); }
bool is_overlapping(const Bitmap<64>& map2) const { return (map & map2.map)!= 0; } bool is_overlapping(const Bitmap<64>& map2) const { return (map & map2.map)!= 0; }
bool operator==(const Bitmap<64>& map2) const { return map == map2.map; } bool operator==(const Bitmap<64>& map2) const { return map == map2.map; }
char *print(char *buf) const { longlong2str(map,buf,16); return buf; } char *print(char *buf) const {
longlong2str(longlong(map), buf, 16);
return buf;
}
ulonglong to_ulonglong() const { return map; } ulonglong to_ulonglong() const { return map; }
class Iterator : public Table_map_iterator class Iterator : public Table_map_iterator
{ {

4
sql/sql_lifo_buffer.h
View File

@ -84,7 +84,7 @@ public:
start= start_arg; start= start_arg;
end= end_arg; end= end_arg;
if (end != start) if (end != start)
TRASH_ALLOC(start, end - start); TRASH_ALLOC(start, size_t(end - start));
reset(); reset();
} }
@ -224,7 +224,7 @@ public:
{ {
DBUG_ASSERT(unused_end >= unused_start); DBUG_ASSERT(unused_end >= unused_start);
DBUG_ASSERT(end == unused_start); DBUG_ASSERT(end == unused_start);
TRASH_ALLOC(unused_start, unused_end - unused_start); TRASH_ALLOC(unused_start, size_t(unused_end - unused_start));
end= unused_end; end= unused_end;
} }
/* Return pointer to start of the memory area that is occupied by the data */ /* Return pointer to start of the memory area that is occupied by the data */

2
sql/sql_string.h
View File

@ -628,7 +628,7 @@ public:
{ {
char *buff= Ptr + str_length; char *buff= Ptr + str_length;
char *end= ll2str(i, buff, radix, 0); char *end= ll2str(i, buff, radix, 0);
str_length+= (int) (end-buff); str_length+= uint32(end-buff);
} }
/* Inline (general) functions used by the protocol functions */ /* Inline (general) functions used by the protocol functions */

73
storage/innobase/btr/btr0cur.cc
View File

@ -5758,43 +5758,41 @@ the number of pages between slot1->page and slot2->page (which is
n_rows_on_prev_level). In this case we set is_n_rows_exact to FALSE. n_rows_on_prev_level). In this case we set is_n_rows_exact to FALSE.
@return number of rows, not including the borders (exact or estimated) */ @return number of rows, not including the borders (exact or estimated) */
static static
int64_t ha_rows
btr_estimate_n_rows_in_range_on_level( btr_estimate_n_rows_in_range_on_level(
/*==================================*/ /*==================================*/
dict_index_t* index, /*!< in: index */ dict_index_t* index, /*!< in: index */
btr_path_t* slot1, /*!< in: left border */ btr_path_t* slot1, /*!< in: left border */
btr_path_t* slot2, /*!< in: right border */ btr_path_t* slot2, /*!< in: right border */
int64_t n_rows_on_prev_level, /*!< in: number of rows ha_rows n_rows_on_prev_level, /*!< in: number of rows
on the previous level for the on the previous level for the
same descend paths; used to same descend paths; used to
determine the number of pages determine the number of pages
on this level */ on this level */
ibool* is_n_rows_exact) /*!< out: TRUE if the returned bool* is_n_rows_exact) /*!< out: TRUE if the returned
value is exact i.e. not an value is exact i.e. not an
estimation */ estimation */
{ {
int64_t n_rows; ha_rows n_rows = 0;
int n_pages_read = 0; uint n_pages_read = 0;
ulint level; ulint level;
n_rows = 0;
/* Assume by default that we will scan all pages between /* Assume by default that we will scan all pages between
slot1->page_no and slot2->page_no. */ slot1->page_no and slot2->page_no. */
*is_n_rows_exact = TRUE; *is_n_rows_exact = true;
/* Add records from slot1->page_no which are to the right of /* Add records from slot1->page_no which are to the right of
the record which serves as a left border of the range, if any the record which serves as a left border of the range, if any
(we don't include the record itself in this count). */ (we don't include the record itself in this count). */
if (slot1->nth_rec <= slot1->n_recs) { if (slot1->nth_rec <= slot1->n_recs) {
n_rows += int64_t(slot1->n_recs - slot1->nth_rec); n_rows += slot1->n_recs - slot1->nth_rec;
} }
/* Add records from slot2->page_no which are to the left of /* Add records from slot2->page_no which are to the left of
the record which servers as a right border of the range, if any the record which servers as a right border of the range, if any
(we don't include the record itself in this count). */ (we don't include the record itself in this count). */
if (slot2->nth_rec > 1) { if (slot2->nth_rec > 1) {
n_rows += int64_t(slot2->nth_rec) - 1; n_rows += slot2->nth_rec - 1;
} }
/* Count the records in the pages between slot1->page_no and /* Count the records in the pages between slot1->page_no and
@ -5897,7 +5895,7 @@ btr_estimate_n_rows_in_range_on_level(
inexact: inexact:
*is_n_rows_exact = FALSE; *is_n_rows_exact = false;
/* We did interrupt before reaching slot2->page */ /* We did interrupt before reaching slot2->page */
@ -5905,8 +5903,7 @@ inexact:
/* The number of pages on this level is /* The number of pages on this level is
n_rows_on_prev_level, multiply it by the n_rows_on_prev_level, multiply it by the
average number of recs per page so far */ average number of recs per page so far */
n_rows = n_rows_on_prev_level n_rows = n_rows_on_prev_level * n_rows / n_pages_read;
* n_rows / n_pages_read;
} else { } else {
/* The tree changed before we could even /* The tree changed before we could even
start with slot1->page_no */ start with slot1->page_no */
@ -5925,7 +5922,7 @@ static const unsigned rows_in_range_max_retries = 4;
/** We pretend that a range has that many records if the tree keeps changing /** We pretend that a range has that many records if the tree keeps changing
for rows_in_range_max_retries retries while we try to estimate the records for rows_in_range_max_retries retries while we try to estimate the records
in a given range. */ in a given range. */
static const int64_t rows_in_range_arbitrary_ret_val = 10; static const ha_rows rows_in_range_arbitrary_ret_val = 10;
/** Estimates the number of rows in a given index range. /** Estimates the number of rows in a given index range.
@param[in] index index @param[in] index index
@ -5942,7 +5939,7 @@ rows_in_range_arbitrary_ret_val as a result (if
nth_attempt >= rows_in_range_max_retries and the tree is modified between nth_attempt >= rows_in_range_max_retries and the tree is modified between
the two dives). */ the two dives). */
static static
int64_t ha_rows
btr_estimate_n_rows_in_range_low( btr_estimate_n_rows_in_range_low(
dict_index_t* index, dict_index_t* index,
const dtuple_t* tuple1, const dtuple_t* tuple1,
@ -5956,16 +5953,16 @@ btr_estimate_n_rows_in_range_low(
btr_cur_t cursor; btr_cur_t cursor;
btr_path_t* slot1; btr_path_t* slot1;
btr_path_t* slot2; btr_path_t* slot2;
ibool diverged; bool diverged;
ibool diverged_lot; bool diverged_lot;
ulint divergence_level; ulint divergence_level;
int64_t n_rows; ha_rows n_rows;
ibool is_n_rows_exact; bool is_n_rows_exact;
ulint i; ulint i;
mtr_t mtr; mtr_t mtr;
int64_t table_n_rows; ha_rows table_n_rows;
table_n_rows = int64_t(dict_table_get_n_rows(index->table)); table_n_rows = dict_table_get_n_rows(index->table);
/* Below we dive to the two records specified by tuple1 and tuple2 and /* Below we dive to the two records specified by tuple1 and tuple2 and
we remember the entire dive paths from the tree root. The place where we remember the entire dive paths from the tree root. The place where
@ -6099,16 +6096,16 @@ btr_estimate_n_rows_in_range_low(
/* We have the path information for the range in path1 and path2 */ /* We have the path information for the range in path1 and path2 */
n_rows = 0; n_rows = 0;
is_n_rows_exact = TRUE; is_n_rows_exact = true;
/* This becomes true when the two paths do not pass through the /* This becomes true when the two paths do not pass through the
same pages anymore. */ same pages anymore. */
diverged = FALSE; diverged = false;
/* This becomes true when the paths are not the same or adjacent /* This becomes true when the paths are not the same or adjacent
any more. This means that they pass through the same or any more. This means that they pass through the same or
neighboring-on-the-same-level pages only. */ neighboring-on-the-same-level pages only. */
diverged_lot = FALSE; diverged_lot = false;
/* This is the level where paths diverged a lot. */ /* This is the level where paths diverged a lot. */
divergence_level = 1000000; divergence_level = 1000000;
@ -6231,21 +6228,17 @@ btr_estimate_n_rows_in_range_low(
return(rows_in_range_arbitrary_ret_val); return(rows_in_range_arbitrary_ret_val);
} }
const int64_t ret = return btr_estimate_n_rows_in_range_low(
btr_estimate_n_rows_in_range_low(
index, tuple1, mode1, index, tuple1, mode1,
tuple2, mode2, nth_attempt + 1); tuple2, mode2, nth_attempt + 1);
return(ret);
} }
diverged = TRUE; diverged = true;
if (slot1->nth_rec < slot2->nth_rec) { if (slot1->nth_rec < slot2->nth_rec) {
/* We do not count the borders (nor the left /* We do not count the borders (nor the left
nor the right one), thus "- 1". */ nor the right one), thus "- 1". */
n_rows = int64_t(slot2->nth_rec n_rows = slot2->nth_rec - slot1->nth_rec - 1;
- slot1->nth_rec) - 1;
if (n_rows > 0) { if (n_rows > 0) {
/* There is at least one row between /* There is at least one row between
@ -6253,7 +6246,7 @@ btr_estimate_n_rows_in_range_low(
and slot2, so on the level below the and slot2, so on the level below the
slots will point to non-adjacent slots will point to non-adjacent
pages. */ pages. */
diverged_lot = TRUE; diverged_lot = true;
divergence_level = i; divergence_level = i;
} }
} else { } else {
@ -6275,18 +6268,18 @@ btr_estimate_n_rows_in_range_low(
if (slot1->nth_rec < slot1->n_recs if (slot1->nth_rec < slot1->n_recs
|| slot2->nth_rec > 1) { || slot2->nth_rec > 1) {
diverged_lot = TRUE; diverged_lot = true;
divergence_level = i; divergence_level = i;
n_rows = 0; n_rows = 0;
if (slot1->nth_rec < slot1->n_recs) { if (slot1->nth_rec < slot1->n_recs) {
n_rows += int64_t(slot1->n_recs n_rows += slot1->n_recs
- slot1->nth_rec); - slot1->nth_rec;
} }
if (slot2->nth_rec > 1) { if (slot2->nth_rec > 1) {
n_rows += int64_t(slot2->nth_rec) - 1; n_rows += slot2->nth_rec - 1;
} }
} }
} else if (diverged_lot) { } else if (diverged_lot) {
@ -6305,7 +6298,7 @@ btr_estimate_n_rows_in_range_low(
@param[in] tuple2 range end, may also be empty tuple @param[in] tuple2 range end, may also be empty tuple
@param[in] mode2 search mode for range end @param[in] mode2 search mode for range end
@return estimated number of rows */ @return estimated number of rows */
int64_t ha_rows
btr_estimate_n_rows_in_range( btr_estimate_n_rows_in_range(
dict_index_t* index, dict_index_t* index,
const dtuple_t* tuple1, const dtuple_t* tuple1,
@ -6313,10 +6306,8 @@ btr_estimate_n_rows_in_range(
const dtuple_t* tuple2, const dtuple_t* tuple2,
page_cur_mode_t mode2) page_cur_mode_t mode2)
{ {
const int64_t ret = btr_estimate_n_rows_in_range_low( return btr_estimate_n_rows_in_range_low(
index, tuple1, mode1, tuple2, mode2, 1 /* first attempt */); index, tuple1, mode1, tuple2, mode2, 1);
return(ret);
} }
/*******************************************************************//** /*******************************************************************//**

5
storage/innobase/gis/gis0rtree.cc
View File

@ -1843,7 +1843,7 @@ rtr_rec_cal_increase(
@param[in] tuple range tuple containing mbr, may also be empty tuple @param[in] tuple range tuple containing mbr, may also be empty tuple
@param[in] mode search mode @param[in] mode search mode
@return estimated number of rows */ @return estimated number of rows */
int64_t ha_rows
rtr_estimate_n_rows_in_range( rtr_estimate_n_rows_in_range(
dict_index_t* index, dict_index_t* index,
const dtuple_t* tuple, const dtuple_t* tuple,
@ -1994,6 +1994,5 @@ rtr_estimate_n_rows_in_range(
return(HA_POS_ERROR); return(HA_POS_ERROR);
} }
return(static_cast<int64_t>(dict_table_get_n_rows(index->table) return dict_table_get_n_rows(index->table) * area / n_recs;
* area / n_recs));
} }

2
storage/innobase/handler/ha_innodb.cc
View File

@ -13383,7 +13383,7 @@ ha_innobase::records_in_range(
dict_index_t* index; dict_index_t* index;
dtuple_t* range_start; dtuple_t* range_start;
dtuple_t* range_end; dtuple_t* range_end;
int64_t n_rows; ha_rows n_rows;
page_cur_mode_t mode1; page_cur_mode_t mode1;
page_cur_mode_t mode2; page_cur_mode_t mode2;
mem_heap_t* heap; mem_heap_t* heap;

3
storage/innobase/include/btr0cur.h
View File

@ -28,6 +28,7 @@ Created 10/16/1994 Heikki Tuuri
#define btr0cur_h #define btr0cur_h
#include "univ.i" #include "univ.i"
#include "my_base.h"
#include "dict0dict.h" #include "dict0dict.h"
#include "page0cur.h" #include "page0cur.h"
#include "btr0types.h" #include "btr0types.h"
@ -600,7 +601,7 @@ btr_cur_parse_del_mark_set_sec_rec(
@param[in] tuple2 range end, may also be empty tuple @param[in] tuple2 range end, may also be empty tuple
@param[in] mode2 search mode for range end @param[in] mode2 search mode for range end
@return estimated number of rows */ @return estimated number of rows */
int64_t ha_rows
btr_estimate_n_rows_in_range( btr_estimate_n_rows_in_range(
dict_index_t* index, dict_index_t* index,
const dtuple_t* tuple1, const dtuple_t* tuple1,

3
storage/innobase/include/gis0rtree.h
View File

@ -28,6 +28,7 @@ Created 2013/03/27 Jimmy Yang and Allen Lai
#define gis0rtree_h #define gis0rtree_h
#include "univ.i" #include "univ.i"
#include "my_base.h"
#include "data0type.h" #include "data0type.h"
#include "data0types.h" #include "data0types.h"
@ -543,7 +544,7 @@ rtr_info_reinit_in_cursor(
@param[in] tuple range tuple containing mbr, may also be empty tuple @param[in] tuple range tuple containing mbr, may also be empty tuple
@param[in] mode search mode @param[in] mode search mode
@return estimated number of rows */ @return estimated number of rows */
int64_t ha_rows
rtr_estimate_n_rows_in_range( rtr_estimate_n_rows_in_range(
dict_index_t* index, dict_index_t* index,
const dtuple_t* tuple, const dtuple_t* tuple,

2
storage/innobase/trx/trx0sys.cc
View File

@ -195,7 +195,7 @@ trx_sysf_create(
ut_a(ptr <= page + (srv_page_size - FIL_PAGE_DATA_END)); ut_a(ptr <= page + (srv_page_size - FIL_PAGE_DATA_END));
/* Initialize all of the page. This part used to be uninitialized. */ /* Initialize all of the page. This part used to be uninitialized. */
memset(ptr, 0, srv_page_size - FIL_PAGE_DATA_END + page - ptr); memset(ptr, 0, srv_page_size - FIL_PAGE_DATA_END + size_t(page - ptr));
mlog_log_string(TRX_SYS + page, srv_page_size - FIL_PAGE_DATA_END mlog_log_string(TRX_SYS + page, srv_page_size - FIL_PAGE_DATA_END
- TRX_SYS, mtr); - TRX_SYS, mtr);