MDEV-15091 : Windows, 64bit: reenable and fix warning C4267 (conversion from 'size_t' to 'type', possible loss of data)

Handle string length as size_t, consistently (almost always:))
Change function prototypes to accept size_t, where in the past
ulong or uint were used. change local/member variables to size_t
when appropriate.

This fix excludes rocksdb, spider,spider, sphinx and connect for now.

135 files changed, 1074 insertions, 1120 deletions

diff --git a/sql/create_options.cc b/sql/create_options.cc
index d0a155c097f..7837beb516f 100644
--- a/sql/create_options.cc
+++ b/sql/create_options.cc
@@ -545,7 +545,7 @@ uint engine_option_value::frm_length()
 
     if value.str is NULL, this option is not written to frm (=DEFAULT)
   */
-  return value.str ? 1 + name.length + 2 + value.length : 0;
+  return value.str ? (uint)(1 + name.length + 2 + value.length) : 0;
 }
 
 
@@ -730,7 +730,7 @@ uchar *engine_option_value::frm_read(const uchar *buff, const uchar *buff_end,
   @retval FALSE OK
 */
 
-bool engine_table_options_frm_read(const uchar *buff, uint length,
+bool engine_table_options_frm_read(const uchar *buff, size_t length,
                                    TABLE_SHARE *share)
 {
   const uchar *buff_end= buff + length;
diff --git a/sql/create_options.h b/sql/create_options.h
index 41e8abcb232..c82cb875743 100644
--- a/sql/create_options.h
+++ b/sql/create_options.h
@@ -87,7 +87,7 @@ bool parse_option_list(THD* thd, handlerton *hton, void *option_struct,
                        engine_option_value **option_list,
                        ha_create_table_option *rules,
                        bool suppress_warning, MEM_ROOT *root);
-bool engine_table_options_frm_read(const uchar *buff, uint length,
+bool engine_table_options_frm_read(const uchar *buff, size_t length,
                                    TABLE_SHARE *share);
 engine_option_value *merge_engine_table_options(engine_option_value *source,
                                                 engine_option_value *changes,
diff --git a/sql/debug_sync.cc b/sql/debug_sync.cc
index d44b313ec24..58a01a77849 100644
--- a/sql/debug_sync.cc
+++ b/sql/debug_sync.cc
@@ -465,13 +465,13 @@ static int debug_sync_qsort_cmp(const void* arg1, const void* arg2)
 static st_debug_sync_action *debug_sync_find(st_debug_sync_action *actionarr,
                                              int quantity,
                                              const char *dsp_name,
-                                             uint name_len)
+                                             size_t name_len)
 {
   st_debug_sync_action  *action;
   int                   low ;
   int                   high ;
   int                   mid ;
-  int                   diff ;
+  ssize_t               diff ;
   DBUG_ASSERT(actionarr);
   DBUG_ASSERT(dsp_name);
   DBUG_ASSERT(name_len);
diff --git a/sql/des_key_file.cc b/sql/des_key_file.cc
index e7785a0a223..1f81fb9fd3f 100644
--- a/sql/des_key_file.cc
+++ b/sql/des_key_file.cc
@@ -59,7 +59,7 @@ load_des_key_file(const char *file_name)
     char *start, *end;
     char buf[1024], offset;
     st_des_keyblock keyblock;
-    uint length;
+    size_t length;
 
     if (!(length=my_b_gets(&io,buf,sizeof(buf)-1)))
       break;					// End of file
diff --git a/sql/discover.cc b/sql/discover.cc
index a683166fb7f..7184cde5e03 100644
--- a/sql/discover.cc
+++ b/sql/discover.cc
@@ -136,7 +136,7 @@ int writefrm(const char *path, const char *db, const char *table,
   }
   else
   {
-    error= mysql_file_write(file, frmdata, len, MYF(MY_WME | MY_NABP));
+    error= (int)mysql_file_write(file, frmdata, len, MYF(MY_WME | MY_NABP));
 
     if (!error && !tmp_table && opt_sync_frm)
         error= mysql_file_sync(file, MYF(MY_WME)) ||
diff --git a/sql/field.cc b/sql/field.cc
index bba6d9ee1e5..d9534021a0d 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -1228,7 +1228,7 @@ bool Field::can_optimize_range(const Item_bool_func *cond,
 }
 
 
-int Field::store_hex_hybrid(const char *str, uint length)
+int Field::store_hex_hybrid(const char *str, size_t length)
 {
   DBUG_ASSERT(result_type() != STRING_RESULT);
   ulonglong nr;
@@ -1467,8 +1467,7 @@ Value_source::Converter_string_to_number::check_edom_and_truncation(THD *thd,
 int Field_num::check_edom_and_important_data_truncation(const char *type,
                                                         bool edom,
                                                         CHARSET_INFO *cs,
-                                                        const char *str,
-                                                        uint length,
+                                                        const char *str, size_t length,
                                                         const char *end)
 {
   /* Test if we get an empty string or garbage */
@@ -1490,7 +1489,7 @@ int Field_num::check_edom_and_important_data_truncation(const char *type,
 
 int Field_num::check_edom_and_truncation(const char *type, bool edom,
                                          CHARSET_INFO *cs,
-                                         const char *str, uint length,
+                                         const char *str, size_t length,
                                          const char *end)
 {
   int rc= check_edom_and_important_data_truncation(type, edom,
@@ -1524,7 +1523,7 @@ int Field_num::check_edom_and_truncation(const char *type, bool edom,
     1   error
 */
 
-bool Field_num::get_int(CHARSET_INFO *cs, const char *from, uint len,
+bool Field_num::get_int(CHARSET_INFO *cs, const char *from, size_t len,
                         longlong *rnd, ulonglong unsigned_max, 
                         longlong signed_min, longlong signed_max)
 {
@@ -1568,7 +1567,7 @@ out_of_range:
 }
 
 
-double Field_real::get_double(const char *str, uint length, CHARSET_INFO *cs,
+double Field_real::get_double(const char *str, size_t length, CHARSET_INFO *cs,
                               int *error)
 {
   char *end;
@@ -1754,7 +1753,7 @@ bool Field::compatible_field_size(uint field_metadata,
 }
 
 
-int Field::store(const char *to, uint length, CHARSET_INFO *cs,
+int Field::store(const char *to, size_t length, CHARSET_INFO *cs,
                  enum_check_fields check_level)
 {
   int res;
@@ -2466,7 +2465,7 @@ void Field_decimal::overflow(bool negative)
 }
 
 
-int Field_decimal::store(const char *from_arg, uint len, CHARSET_INFO *cs)
+int Field_decimal::store(const char *from_arg, size_t len, CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   char buff[STRING_BUFFER_USUAL_SIZE];
@@ -2847,7 +2846,6 @@ int Field_decimal::store(double nr)
     return 1;
   }
 
-  reg4 uint i;
   size_t length;
   uchar fyllchar,*to;
   char buff[DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE];
@@ -2863,7 +2861,7 @@ int Field_decimal::store(double nr)
   else
   {
     to=ptr;
-    for (i=field_length-length ; i-- > 0 ;)
+    for (size_t i=field_length-length ; i-- > 0 ;)
       *to++ = fyllchar;
     memcpy(to,buff,length);
     return 0;
@@ -3149,7 +3147,7 @@ bool Field_new_decimal::store_value(const my_decimal *decimal_value)
 }
 
 
-int Field_new_decimal::store(const char *from, uint length,
+int Field_new_decimal::store(const char *from, size_t length,
                              CHARSET_INFO *charset_arg)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
@@ -3356,7 +3354,7 @@ int Field_new_decimal::cmp(const uchar *a,const uchar*b)
 
 
 void Field_new_decimal::sort_string(uchar *buff,
-                                    uint length __attribute__((unused)))
+                                    uint)
 {
   memcpy(buff, ptr, bin_size);
 }
@@ -3540,7 +3538,7 @@ int Field_num::store_time_dec(const MYSQL_TIME *ltime, uint dec_arg)
 ** tiny int
 ****************************************************************************/
 
-int Field_tiny::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_tiny::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int error;
@@ -3716,7 +3714,7 @@ void Field_tiny::sql_type(String &res) const
  Field type short int (2 byte)
 ****************************************************************************/
 
-int Field_short::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_short::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int store_tmp;
@@ -3905,7 +3903,7 @@ void Field_short::sql_type(String &res) const
   Field type medium int (3 byte)
 ****************************************************************************/
 
-int Field_medium::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_medium::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int store_tmp;
@@ -4096,7 +4094,7 @@ void Field_medium::sql_type(String &res) const
 ** long int
 ****************************************************************************/
 
-int Field_long::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_long::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   long store_tmp;
@@ -4224,17 +4222,17 @@ String *Field_long::val_str(String *val_buffer,
 {
   ASSERT_COLUMN_MARKED_FOR_READ;
   CHARSET_INFO *cs= &my_charset_numeric;
-  uint length;
-  uint mlength=MY_MAX(field_length+1,12*cs->mbmaxlen);
+  size_t length;
+  size_t mlength=MY_MAX(field_length+1,12*cs->mbmaxlen);
   val_buffer->alloc(mlength);
   char *to=(char*) val_buffer->ptr();
   int32 j;
   j=sint4korr(ptr);
 
   if (unsigned_flag)
-    length=cs->cset->long10_to_str(cs,to,mlength, 10,(long) (uint32)j);
+    length=cs->cset->long10_to_str(cs,to,mlength, 10,(uint32) j);
   else
-    length=cs->cset->long10_to_str(cs,to,mlength,-10,(long) j);
+    length=cs->cset->long10_to_str(cs,to,mlength,-10,j);
   val_buffer->length(length);
   if (zerofill)
     prepend_zeros(val_buffer);
@@ -4283,7 +4281,7 @@ void Field_long::sql_type(String &res) const
  Field type longlong int (8 bytes)
 ****************************************************************************/
 
-int Field_longlong::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_longlong::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int error= 0;
@@ -4459,7 +4457,7 @@ bool Field_longlong::is_max()
   single precision float
 ****************************************************************************/
 
-int Field_float::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_float::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   int error;
   Field_float::store(get_double(from, len, cs, &error));
@@ -4638,7 +4636,7 @@ void Field_float::sql_type(String &res) const
   double precision floating point numbers
 ****************************************************************************/
 
-int Field_double::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_double::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   int error;
   Field_double::store(get_double(from, len, cs, &error));
@@ -5098,7 +5096,7 @@ int Field_timestamp::store_time_dec(const MYSQL_TIME *ltime, uint dec)
 }
 
 
-int Field_timestamp::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_timestamp::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   MYSQL_TIME l_time;
   MYSQL_TIME_STATUS status;
@@ -5600,7 +5598,7 @@ int Field_temporal_with_date::store_TIME_with_warning(MYSQL_TIME *ltime,
 }
 
 
-int Field_temporal_with_date::store(const char *from, uint len, CHARSET_INFO *cs)
+int Field_temporal_with_date::store(const char *from, size_t len, CHARSET_INFO *cs)
 {
   MYSQL_TIME ltime;
   MYSQL_TIME_STATUS status;
@@ -5796,7 +5794,7 @@ void Field_time::store_TIME(const MYSQL_TIME *ltime)
   int3store(ptr,tmp);
 }
 
-int Field_time::store(const char *from,uint len,CHARSET_INFO *cs)
+int Field_time::store(const char *from,size_t len,CHARSET_INFO *cs)
 {
   MYSQL_TIME ltime;
   MYSQL_TIME_STATUS status;
@@ -6228,7 +6226,7 @@ bool Field_timef::get_date(MYSQL_TIME *ltime, ulonglong fuzzydate)
 ** Can handle 2 byte or 4 byte years!
 ****************************************************************************/
 
-int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
+int Field_year::store(const char *from, size_t len,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   char *end;
@@ -6972,7 +6970,7 @@ Field_longstr::report_if_important_data(const char *pstr, const char *end,
 
 	/* Copy a string and fill with space */
 
-int Field_string::store(const char *from,uint length,CHARSET_INFO *cs)
+int Field_string::store(const char *from, size_t length,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   uint copy_length;
@@ -7038,7 +7036,7 @@ int Field_str::store(double nr)
     else
       set_warning(WARN_DATA_TRUNCATED, 1);
   }
-  return store(buff, length, &my_charset_numeric);
+  return store(buff, (uint)length, &my_charset_numeric);
 }
 
 uint Field::is_equal(Create_field *new_field)
@@ -7170,7 +7168,7 @@ String *Field_string::val_str(String *val_buffer __attribute__((unused)),
   ASSERT_COLUMN_MARKED_FOR_READ;
   /* See the comment for Field_long::store(long long) */
   DBUG_ASSERT(!table || table->in_use == current_thd);
-  uint length;
+  size_t length;
   if (get_thd()->variables.sql_mode &
       MODE_PAD_CHAR_TO_FULL_LENGTH)
     length= my_charpos(field_charset, ptr, ptr + field_length,
@@ -7233,11 +7231,11 @@ Field_string::compatible_field_size(uint field_metadata,
 
 int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr)
 {
-  uint a_len, b_len;
+  size_t a_len, b_len;
 
   if (field_charset->mbmaxlen != 1)
   {
-    uint char_len= field_length/field_charset->mbmaxlen;
+    size_t char_len= field_length/field_charset->mbmaxlen;
     a_len= my_charpos(field_charset, a_ptr, a_ptr + field_length, char_len);
     b_len= my_charpos(field_charset, b_ptr, b_ptr + field_length, char_len);
   }
@@ -7255,7 +7253,7 @@ int Field_string::cmp(const uchar *a_ptr, const uchar *b_ptr)
 
 void Field_string::sort_string(uchar *to,uint length)
 {
-  uint tmp __attribute__((unused))=
+  IF_DBUG(size_t tmp= ,)
     field_charset->coll->strnxfrm(field_charset,
                                   to, length,
                                   char_length() *
@@ -7271,7 +7269,7 @@ void Field_string::sql_type(String &res) const
 {
   THD *thd= table->in_use;
   CHARSET_INFO *cs=res.charset();
-  ulong length;
+  size_t length;
 
   length= cs->cset->snprintf(cs,(char*) res.ptr(),
                              res.alloced_length(), "%s(%d)",
@@ -7288,9 +7286,9 @@ void Field_string::sql_type(String &res) const
 
 uchar *Field_string::pack(uchar *to, const uchar *from, uint max_length)
 {
-  uint length=      MY_MIN(field_length,max_length);
-  uint local_char_length= max_length/field_charset->mbmaxlen;
-  DBUG_PRINT("debug", ("Packing field '%s' - length: %u ", field_name.str,
+  size_t length=      MY_MIN(field_length,max_length);
+  size_t local_char_length= max_length/field_charset->mbmaxlen;
+  DBUG_PRINT("debug", ("Packing field '%s' - length: %zu ", field_name.str,
                        length));
 
   if (length > local_char_length)
@@ -7445,14 +7443,14 @@ uint Field_string::max_packed_col_length(uint max_length)
 
 uint Field_string::get_key_image(uchar *buff, uint length, imagetype type_arg)
 {
-  uint bytes = my_charpos(field_charset, (char*) ptr,
+  size_t bytes = my_charpos(field_charset, (char*) ptr,
                           (char*) ptr + field_length,
                           length / field_charset->mbmaxlen);
   memcpy(buff, ptr, bytes);
   if (bytes < length)
     field_charset->cset->fill(field_charset, (char*) buff + bytes,
                               length - bytes, field_charset->pad_char);
-  return bytes;
+  return (uint)bytes;
 }
 
 
@@ -7521,7 +7519,7 @@ int Field_varstring::save_field_metadata(uchar *metadata_ptr)
   return 2;
 }
 
-int Field_varstring::store(const char *from,uint length,CHARSET_INFO *cs)
+int Field_varstring::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   uint copy_length;
@@ -7622,8 +7620,8 @@ int Field_varstring::cmp_max(const uchar *a_ptr, const uchar *b_ptr,
 
 int Field_varstring::key_cmp(const uchar *key_ptr, uint max_key_length)
 {
-  uint length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
-  uint local_char_length= max_key_length / field_charset->mbmaxlen;
+  size_t length=  length_bytes == 1 ? (uint) *ptr : uint2korr(ptr);
+  size_t local_char_length= max_key_length / field_charset->mbmaxlen;
 
   local_char_length= my_charpos(field_charset, ptr + length_bytes,
                           ptr + length_bytes + length, local_char_length);
@@ -7672,7 +7670,7 @@ void Field_varstring::sort_string(uchar *to,uint length)
   }
 
 #ifndef DBUG_OFF
-    uint rc=
+    size_t rc=
 #endif
   field_charset->coll->strnxfrm(field_charset, to, length,
                                 char_length() * field_charset->strxfrm_multiply,
@@ -7704,7 +7702,7 @@ void Field_varstring::sql_type(String &res) const
 {
   THD *thd= table->in_use;
   CHARSET_INFO *cs=res.charset();
-  ulong length;
+  size_t length;
 
   length= cs->cset->snprintf(cs,(char*) res.ptr(),
                              res.alloced_length(), "%s(%d)",
@@ -8053,12 +8051,12 @@ String *Field_longstr::uncompress(String *val_buffer, String *val_ptr,
 }
 
 
-int Field_varstring_compressed::store(const char *from, uint length,
+int Field_varstring_compressed::store(const char *from, size_t length,
                                       CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
-  uint to_length= MY_MIN(field_length, field_charset->mbmaxlen * length + 1);
-  int rc= compress((char*) get_data(), &to_length, from, length, cs);
+  uint to_length= (uint)MY_MIN(field_length, field_charset->mbmaxlen * length + 1);
+  int rc= compress((char*) get_data(), &to_length, from, (uint)length, cs);
   store_length(to_length);
   return rc;
 }
@@ -8183,10 +8181,10 @@ int Field_blob::copy_value(Field_blob *from)
 }
 
 
-int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
+int Field_blob::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
-  uint copy_length, new_length;
+  size_t copy_length, new_length;
   String_copier copier;
   char *tmp;
   char buff[STRING_BUFFER_USUAL_SIZE];
@@ -8205,7 +8203,7 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
     DBUG_ASSERT(length <= max_data_length());
     
     new_length= length;
-    copy_length= (uint)MY_MIN(UINT_MAX,table->in_use->variables.group_concat_max_len);
+    copy_length= (size_t)MY_MIN(UINT_MAX,table->in_use->variables.group_concat_max_len);
     if (new_length > copy_length)
     {
       new_length= Well_formed_prefix(cs,
@@ -8258,7 +8256,7 @@ int Field_blob::store(const char *from,uint length,CHARSET_INFO *cs)
     return 0;
   }
   copy_length= copier.well_formed_copy(field_charset,
-                                       (char*) value.ptr(), new_length,
+                                       (char*) value.ptr(), (uint)new_length,
                                        cs, from, length);
   Field_blob::store_length(copy_length);
   bmove(ptr+packlength,(uchar*) &tmp,sizeof(char*));
@@ -8381,7 +8379,7 @@ int Field_blob::cmp_binary(const uchar *a_ptr, const uchar *b_ptr,
 
 uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg)
 {
-  uint32 blob_length= get_length(ptr);
+  size_t blob_length= get_length(ptr);
   uchar *blob;
 
 #ifdef HAVE_SPATIAL
@@ -8399,7 +8397,7 @@ uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg)
       return image_length;
     }
     blob= get_ptr();
-    gobj= Geometry::construct(&buffer, (char*) blob, blob_length);
+    gobj= Geometry::construct(&buffer, (char*) blob, (uint32)blob_length);
     if (!gobj || gobj->get_mbr(&mbr, &dummy))
       bzero(buff, image_length);
     else
@@ -8414,12 +8412,12 @@ uint Field_blob::get_key_image(uchar *buff,uint length, imagetype type_arg)
 #endif /*HAVE_SPATIAL*/
 
   blob= get_ptr();
-  uint local_char_length= length / field_charset->mbmaxlen;
+  size_t local_char_length= length / field_charset->mbmaxlen;
   local_char_length= my_charpos(field_charset, blob, blob + blob_length,
                           local_char_length);
   set_if_smaller(blob_length, local_char_length);
 
-  if ((uint32) length > blob_length)
+  if (length > blob_length)
   {
     /*
       Must clear this as we do a memcmp in opt_range.cc to detect
@@ -8445,14 +8443,14 @@ void Field_blob::set_key_image(const uchar *buff,uint length)
 int Field_blob::key_cmp(const uchar *key_ptr, uint max_key_length)
 {
   uchar *blob1;
-  uint blob_length=get_length(ptr);
+  size_t blob_length=get_length(ptr);
   memcpy(&blob1, ptr+packlength, sizeof(char*));
   CHARSET_INFO *cs= charset();
-  uint local_char_length= max_key_length / cs->mbmaxlen;
+  size_t local_char_length= max_key_length / cs->mbmaxlen;
   local_char_length= my_charpos(cs, blob1, blob1+blob_length,
                                 local_char_length);
   set_if_smaller(blob_length, local_char_length);
-  return Field_blob::cmp(blob1, blob_length,
+  return Field_blob::cmp(blob1, (uint32)blob_length,
 			 key_ptr+HA_KEY_BLOB_LENGTH,
 			 uint2korr(key_ptr));
 }
@@ -8523,7 +8521,7 @@ void Field_blob::sort_string(uchar *to,uint length)
     }
 
 #ifndef DBUG_OFF
-    uint rc=
+    size_t rc=
 #endif
     field_charset->coll->strnxfrm(field_charset, to, length, length,
                                   (const uchar*) buf.ptr(), buf.length(),
@@ -8663,11 +8661,11 @@ uint Field_blob::is_equal(Create_field *new_field)
 }
 
 
-int Field_blob_compressed::store(const char *from, uint length,
+int Field_blob_compressed::store(const char *from, size_t length,
                                  CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
-  uint to_length= MY_MIN(max_data_length(), field_charset->mbmaxlen * length + 1);
+  uint to_length= (uint)MY_MIN(max_data_length(), field_charset->mbmaxlen * length + 1);
   int rc;
 
   if (value.alloc(to_length))
@@ -8676,7 +8674,7 @@ int Field_blob_compressed::store(const char *from, uint length,
     return -1;
   }
 
-  rc= compress((char*) value.ptr(), &to_length, from, length, cs);
+  rc= compress((char*) value.ptr(), &to_length, from, (uint)length, cs);
   set_ptr(to_length, (uchar*) value.ptr());
   return rc;
 }
@@ -8761,7 +8759,7 @@ uint gis_field_options_image(uchar *buff, List<Create_field> &create_fields)
 }
 
 
-uint gis_field_options_read(const uchar *buf, uint buf_len,
+uint gis_field_options_read(const uchar *buf, size_t buf_len,
       Field_geom::storage_type *st_type,uint *precision, uint *scale, uint *srid)
 {
   const uchar *buf_end= buf + buf_len;
@@ -8867,7 +8865,7 @@ int Field_geom::store_decimal(const my_decimal *)
 }
 
 
-int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
+int Field_geom::store(const char *from, size_t length, CHARSET_INFO *cs)
 {
   if (!length)
     bzero(ptr, Field_blob::pack_length());
@@ -8992,7 +8990,7 @@ void Field_enum::store_type(ulonglong value)
     (if there isn't a empty value in the enum)
 */
 
-int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
+int Field_enum::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int err= 0;
@@ -9009,7 +9007,7 @@ int Field_enum::store(const char *from,uint length,CHARSET_INFO *cs)
   }
 
   /* Remove end space */
-  length= field_charset->cset->lengthsp(field_charset, from, length);
+  length= (uint)field_charset->cset->lengthsp(field_charset, from, length);
   uint tmp=find_type2(typelib, from, length, field_charset);
   if (!tmp)
   {
@@ -9175,7 +9173,7 @@ Field *Field_enum::make_new_field(MEM_ROOT *root, TABLE *new_table,
 */
 
 
-int Field_set::store(const char *from,uint length,CHARSET_INFO *cs)
+int Field_set::store(const char *from,size_t length,CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   bool got_warning= 0;
@@ -9594,14 +9592,14 @@ uint Field_bit::is_equal(Create_field *new_field)
 }
 
                        
-int Field_bit::store(const char *from, uint length, CHARSET_INFO *cs)
+int Field_bit::store(const char *from, size_t length, CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int delta;
 
   for (; length && !*from; from++, length--)          // skip left 0's
     ;
-  delta= bytes_in_rec - length;
+  delta= (int)(bytes_in_rec - length);
 
   if (delta < -1 ||
       (delta == -1 && (uchar) *from > ((1 << bit_len) - 1)) ||
@@ -9877,9 +9875,9 @@ Field_bit::compatible_field_size(uint field_metadata,
 void Field_bit::sql_type(String &res) const
 {
   CHARSET_INFO *cs= res.charset();
-  ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
+  size_t length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
                                    "bit(%d)", (int) field_length);
-  res.length((uint) length);
+  res.length(length);
 }
 
 
@@ -10030,7 +10028,7 @@ Field_bit_as_char::Field_bit_as_char(uchar *ptr_arg, uint32 len_arg,
 }
 
 
-int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
+int Field_bit_as_char::store(const char *from, size_t length, CHARSET_INFO *cs)
 {
   ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED;
   int delta;
@@ -10038,7 +10036,7 @@ int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
 
   for (; length && !*from; from++, length--)          // skip left 0's
     ;
-  delta= bytes_in_rec - length;
+  delta= (int)(bytes_in_rec - length);
 
   if (delta < 0 ||
       (delta == 0 && bits && (uint) (uchar) *from >= (uint) (1 << bits)))
@@ -10061,9 +10059,9 @@ int Field_bit_as_char::store(const char *from, uint length, CHARSET_INFO *cs)
 void Field_bit_as_char::sql_type(String &res) const
 {
   CHARSET_INFO *cs= res.charset();
-  ulong length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
+  size_t length= cs->cset->snprintf(cs, (char*) res.ptr(), res.alloced_length(),
                                    "bit(%d)", (int) field_length);
-  res.length((uint) length);
+  res.length(length);
 }
 
 
@@ -10139,7 +10137,7 @@ bool Column_definition::create_interval_from_interval_list(MEM_ROOT *mem_root,
       }
     }
     interval->type_names[i]= value.str;
-    interval->type_lengths[i]= value.length;
+    interval->type_lengths[i]= (uint)value.length;
   }
   interval->type_names[interval->count]= 0;    // End marker
   interval->type_lengths[interval->count]= 0;
diff --git a/sql/field.h b/sql/field.h
index d2274aaf7e8..d5d49bed551 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -216,7 +216,7 @@ protected:
                              my_decimal *buf)
     {
       DBUG_ASSERT(length < UINT_MAX32);
-      m_error= str2my_decimal(mask, str, (uint) length, cs,
+      m_error= str2my_decimal(mask, str, length, cs,
                               buf, (const char **) &m_end_of_num);
       // E_DEC_TRUNCATED means a very minor truncation: '1e-100' -> 0
       m_edom= m_error && m_error != E_DEC_TRUNCATED;
@@ -314,7 +314,7 @@ protected:
     return decimal_value;
   }
 
-  longlong longlong_from_hex_hybrid(const char *str, uint32 length)
+  longlong longlong_from_hex_hybrid(const char *str, size_t length)
   {
     const char *end= str + length;
     const char *ptr= end - MY_MIN(length, sizeof(longlong));
@@ -824,8 +824,8 @@ public:
     @retval false - conversion is needed
   */
   virtual bool memcpy_field_possible(const Field *from) const= 0;
-  virtual int  store(const char *to, uint length,CHARSET_INFO *cs)=0;
-  virtual int  store_hex_hybrid(const char *str, uint length);
+  virtual int  store(const char *to, size_t length,CHARSET_INFO *cs)=0;
+  virtual int  store_hex_hybrid(const char *str, size_t length);
   virtual int  store(double nr)=0;
   virtual int  store(longlong nr, bool unsigned_val)=0;
   virtual int  store_decimal(const my_decimal *d)=0;
@@ -833,7 +833,7 @@ public:
   virtual int  store_timestamp(my_time_t timestamp, ulong sec_part);
   int store_time(const MYSQL_TIME *ltime)
   { return store_time_dec(ltime, TIME_SECOND_PART_DIGITS); }
-  int store(const char *to, uint length, CHARSET_INFO *cs,
+  int store(const char *to, size_t length, CHARSET_INFO *cs,
             enum_check_fields check_level);
   int store(const LEX_STRING *ls, CHARSET_INFO *cs)
   {
@@ -1644,20 +1644,20 @@ class Field_num :public Field {
 protected:
   int check_edom_and_important_data_truncation(const char *type, bool edom,
                                                CHARSET_INFO *cs,
-                                               const char *str, uint length,
+                                               const char *str, size_t length,
                                                const char *end_of_num);
   int check_edom_and_truncation(const char *type, bool edom,
                                 CHARSET_INFO *cs,
-                                const char *str, uint length,
+                                const char *str, size_t length,
                                 const char *end_of_num);
-  int check_int(CHARSET_INFO *cs, const char *str, uint length,
+  int check_int(CHARSET_INFO *cs, const char *str, size_t length,
                 const char *int_end, int error)
   {
     return check_edom_and_truncation("integer",
                                      error == MY_ERRNO_EDOM || str == int_end,
                                      cs, str, length, int_end);
   }
-  bool get_int(CHARSET_INFO *cs, const char *from, uint len,
+  bool get_int(CHARSET_INFO *cs, const char *from, size_t len,
                longlong *rnd, ulonglong unsigned_max,
                longlong signed_min, longlong signed_max);
   void prepend_zeros(String *value) const;
@@ -1744,8 +1744,8 @@ public:
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_decimal(const my_decimal *);
-  int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
-  int  store_hex_hybrid(const char *str, uint length)
+  int  store(const char *to,size_t length,CHARSET_INFO *cs)=0;
+  int  store_hex_hybrid(const char *str, size_t length)
   {
     return store(str, length, &my_charset_bin);
   }
@@ -1828,7 +1828,7 @@ public:
 /* base class for float and double and decimal (old one) */
 class Field_real :public Field_num {
 protected:
-  double get_double(const char *str, uint length, CHARSET_INFO *cs, int *err);
+  double get_double(const char *str, size_t length, CHARSET_INFO *cs, int *err);
 public:
   bool not_fixed;
 
@@ -1884,7 +1884,7 @@ public:
     return eq_def(from) ? get_identical_copy_func() : do_field_string;
   }
   int reset(void);
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   double val_real(void);
@@ -1943,7 +1943,7 @@ public:
   bool store_value(const my_decimal *decimal_value);
   bool store_value(const my_decimal *decimal_value, int *native_error);
   void set_value_on_overflow(my_decimal *decimal_value, bool sign);
-  int  store(const char *to, uint length, CHARSET_INFO *charset);
+  int  store(const char *to, size_t length, CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_time_dec(const MYSQL_TIME *ltime, uint dec);
@@ -1989,7 +1989,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_tiny; }
   enum ha_base_keytype key_type() const
     { return unsigned_flag ? HA_KEYTYPE_BINARY : HA_KEYTYPE_INT8; }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void) { ptr[0]=0; return 0; }
@@ -2039,7 +2039,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_short; }
   enum ha_base_keytype key_type() const
     { return unsigned_flag ? HA_KEYTYPE_USHORT_INT : HA_KEYTYPE_SHORT_INT;}
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void) { ptr[0]=ptr[1]=0; return 0; }
@@ -2074,7 +2074,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_int24; }
   enum ha_base_keytype key_type() const
     { return unsigned_flag ? HA_KEYTYPE_UINT24 : HA_KEYTYPE_INT24; }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void) { ptr[0]=ptr[1]=ptr[2]=0; return 0; }
@@ -2114,7 +2114,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_long; }
   enum ha_base_keytype key_type() const
     { return unsigned_flag ? HA_KEYTYPE_ULONG_INT : HA_KEYTYPE_LONG_INT; }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=0; return 0; }
@@ -2160,7 +2160,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_longlong; }
   enum ha_base_keytype key_type() const
     { return unsigned_flag ? HA_KEYTYPE_ULONGLONG : HA_KEYTYPE_LONGLONG; }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void)
@@ -2264,7 +2264,7 @@ public:
     }
   const Type_handler *type_handler() const { return &type_handler_float; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_FLOAT; }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int reset(void) { bzero(ptr,sizeof(float)); return 0; }
@@ -2316,7 +2316,7 @@ public:
     }
   const Type_handler *type_handler() const { return &type_handler_double; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_DOUBLE; }
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int reset(void) { bzero(ptr,sizeof(double)); return 0; }
@@ -2351,7 +2351,7 @@ public:
   {
     return do_field_string;
   }
-  int  store(const char *to, uint length, CHARSET_INFO *cs)
+  int  store(const char *to, size_t length, CHARSET_INFO *cs)
   { null[0]=1; return 0; }
   int store(double nr)   { null[0]=1; return 0; }
   int store(longlong nr, bool unsigned_val) { null[0]=1; return 0; }
@@ -2394,7 +2394,7 @@ public:
     :Field(ptr_arg, len_arg, null_ptr_arg, null_bit_arg, unireg_check_arg,
                field_name_arg)
     { flags|= BINARY_FLAG; }
-  int  store_hex_hybrid(const char *str, uint length)
+  int  store_hex_hybrid(const char *str, size_t length)
   {
     return store(str, length, &my_charset_bin);
   }
@@ -2471,7 +2471,7 @@ public:
     :Field_temporal(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
                     unireg_check_arg, field_name_arg)
     {}
-  int  store(const char *to, uint length, CHARSET_INFO *charset);
+  int  store(const char *to, size_t length, CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_time_dec(const MYSQL_TIME *ltime, uint dec);
@@ -2493,7 +2493,7 @@ public:
   const Type_handler *type_handler() const { return &type_handler_timestamp; }
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_ULONG_INT; }
   Copy_func *get_copy_func(const Field *from) const;
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_time_dec(const MYSQL_TIME *ltime, uint dec);
@@ -2696,7 +2696,7 @@ public:
     }
     return do_field_int;
   }
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_time_dec(const MYSQL_TIME *ltime, uint dec);
@@ -2815,7 +2815,7 @@ public:
            decimals() == from->decimals();
   }
   int store_time_dec(const MYSQL_TIME *ltime, uint dec);
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int  store_decimal(const my_decimal *);
@@ -3188,7 +3188,7 @@ public:
                           (has_charset() ? ' ' : 0));
     return 0;
   }
-  int store(const char *to,uint length,CHARSET_INFO *charset);
+  int store(const char *to,size_t length,CHARSET_INFO *charset);
   using Field_str::store;
   double val_real(void);
   longlong val_int(void);
@@ -3292,7 +3292,7 @@ public:
            !compression_method() == !from->compression_method() &&
            length_bytes == ((Field_varstring*) from)->length_bytes;
   }
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   using Field_str::store;
   double val_real(void);
   longlong val_int(void);
@@ -3348,7 +3348,7 @@ public:
   { return compression_method_ptr; }
 private:
   Compression_method *compression_method_ptr;
-  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(const char *to, size_t length, CHARSET_INFO *charset);
   using Field_str::store;
   String *val_str(String *, String *);
   double val_real(void);
@@ -3508,7 +3508,7 @@ public:
            !compression_method() == !from->compression_method() &&
            !table->copy_blobs;
   }
-  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(const char *to, size_t length, CHARSET_INFO *charset);
   using Field_str::store;
   double val_real(void);
   longlong val_int(void);
@@ -3551,9 +3551,10 @@ public:
   void reset_fields() { bzero((uchar*) &value,sizeof(value)); bzero((uchar*) &read_value,sizeof(read_value)); }
   uint32 get_field_buffer_size(void) { return value.alloced_length(); }
   void store_length(uchar *i_ptr, uint i_packlength, uint32 i_number);
-  inline void store_length(uint32 number)
+  inline void store_length(size_t number)
   {
-    store_length(ptr, packlength, number);
+    DBUG_ASSERT(number < UINT_MAX32);
+    store_length(ptr, packlength, (uint32)number);
   }
   inline uint32 get_length(uint row_offset= 0) const
   { return get_length(ptr+row_offset, this->packlength); }
@@ -3661,7 +3662,7 @@ public:
   { return compression_method_ptr; }
 private:
   Compression_method *compression_method_ptr;
-  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(const char *to, size_t length, CHARSET_INFO *charset);
   using Field_str::store;
   String *val_str(String *, String *);
   double val_real(void);
@@ -3728,7 +3729,7 @@ public:
                                   bool is_eq_func) const;
   void sql_type(String &str) const;
   uint is_equal(Create_field *new_field);
-  int  store(const char *to, uint length, CHARSET_INFO *charset);
+  int  store(const char *to, size_t length, CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   int  store_decimal(const my_decimal *);
@@ -3755,7 +3756,7 @@ public:
 };
 
 uint gis_field_options_image(uchar *buff, List<Create_field> &create_fields);
-uint gis_field_options_read(const uchar *buf, uint buf_len,
+uint gis_field_options_read(const uchar *buf, size_t buf_len,
       Field_geom::storage_type *st_type,uint *precision, uint *scale, uint *srid);
 
 #endif /*HAVE_SPATIAL*/
@@ -3809,7 +3810,7 @@ public:
     return save_in_field_str(to);
   }
   bool memcpy_field_possible(const Field *from) const { return false; }
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr, bool unsigned_val);
   double val_real(void);
@@ -3876,7 +3877,7 @@ public:
       flags=(flags & ~ENUM_FLAG) | SET_FLAG;
     }
   int  store_field(Field *from) { return from->save_in_field(this); }
-  int  store(const char *to,uint length,CHARSET_INFO *charset);
+  int  store(const char *to,size_t length,CHARSET_INFO *charset);
   int  store(double nr) { return Field_set::store((longlong) nr, FALSE); }
   int  store(longlong nr, bool unsigned_val);
 
@@ -3932,7 +3933,7 @@ public:
   }
   int save_in_field(Field *to) { return to->store(val_int(), true); }
   bool memcpy_field_possible(const Field *from) const { return false; }
-  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(const char *to, size_t length, CHARSET_INFO *charset);
   int store(double nr);
   int store(longlong nr, bool unsigned_val);
   int store_decimal(const my_decimal *);
@@ -4051,7 +4052,7 @@ public:
                     enum utype unireg_check_arg, const LEX_CSTRING *field_name_arg);
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_BINARY; }
   uint size_of() const { return sizeof(*this); }
-  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(const char *to, size_t length, CHARSET_INFO *charset);
   int store(double nr) { return Field_bit::store(nr); }
   int store(longlong nr, bool unsigned_val)
   { return Field_bit::store(nr, unsigned_val); }
diff --git a/sql/field_conv.cc b/sql/field_conv.cc
index db5c9429954..4ab0f330814 100644
--- a/sql/field_conv.cc
+++ b/sql/field_conv.cc
@@ -389,7 +389,7 @@ static void do_field_varbinary_pre50(Copy_field *copy)
   copy->from_field->val_str(&copy->tmp);
 
   /* Use the same function as in 4.1 to trim trailing spaces */
-  uint length= my_lengthsp_8bit(&my_charset_bin, copy->tmp.c_ptr_quick(),
+  size_t length= my_lengthsp_8bit(&my_charset_bin, copy->tmp.c_ptr_quick(),
                                 copy->from_field->field_length);
 
   copy->to_field->store(copy->tmp.c_ptr_quick(), length,
@@ -481,7 +481,7 @@ static void do_cut_string_complex(Copy_field *copy)
                            (char*) copy->from_ptr,
                            (char*) from_end,
                            copy->to_length / cs->mbmaxlen);
-  uint copy_length= prefix.length();
+  size_t copy_length= prefix.length();
   if (copy->to_length < copy_length)
     copy_length= copy->to_length;
   memcpy(copy->to_ptr, copy->from_ptr, copy_length);
diff --git a/sql/filesort.cc b/sql/filesort.cc
index 4cf2a00dbc4..00dfa08bba8 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -68,7 +68,7 @@ static void unpack_addon_fields(struct st_sort_addon_field *addon_field,
                                 uchar *buff, uchar *buff_end);
 static bool check_if_pq_applicable(Sort_param *param, SORT_INFO *info,
                                    TABLE *table,
-                                   ha_rows records, ulong memory_available);
+                                   ha_rows records, size_t memory_available);
 
 void Sort_param::init_for_filesort(uint sortlen, TABLE *table,
                                    ulong max_length_for_sort_data,
@@ -89,7 +89,10 @@ void Sort_param::init_for_filesort(uint sortlen, TABLE *table,
                                   table->field, sort_length, &addon_buf);
   }
   if (addon_field)
-    res_length= addon_buf.length;
+  {
+    DBUG_ASSERT(addon_buf.length < UINT_MAX32);
+    res_length= (uint)addon_buf.length;
+  }
   else
   {
     res_length= ref_length;
@@ -99,7 +102,7 @@ void Sort_param::init_for_filesort(uint sortlen, TABLE *table,
     */
     sort_length+= ref_length;
   }
-  rec_length= sort_length + addon_buf.length;
+  rec_length= sort_length + (uint)addon_buf.length;
   max_rows= maxrows;
 }
 
@@ -1026,8 +1029,8 @@ Type_handler_string_result::make_sort_key(uchar *to, Item *item,
 
   if (use_strnxfrm(cs))
   {
-    uint tmp_length __attribute__((unused));
-    tmp_length= cs->coll->strnxfrm(cs, to, sort_field->length,
+    IF_DBUG(size_t tmp_length= ,)
+    cs->coll->strnxfrm(cs, to, sort_field->length,
                                    item->max_char_length() *
                                    cs->strxfrm_multiply,
                                    (uchar*) res->ptr(), res->length(),
@@ -1346,10 +1349,10 @@ static bool save_index(Sort_param *param, uint count,
     false - PQ will be slower than merge-sort, or there is not enough memory.
 */
 
-bool check_if_pq_applicable(Sort_param *param,
+static bool check_if_pq_applicable(Sort_param *param,
                             SORT_INFO *filesort_info,
                             TABLE *table, ha_rows num_rows,
-                            ulong memory_available)
+                            size_t memory_available)
 {
   DBUG_ENTER("check_if_pq_applicable");
 
@@ -1371,7 +1374,7 @@ bool check_if_pq_applicable(Sort_param *param,
     DBUG_RETURN(false);
   }
 
-  ulong num_available_keys=
+  size_t num_available_keys=
     memory_available / (param->rec_length + sizeof(char*));
   // We need 1 extra record in the buffer, when using PQ.
   param->max_keys_per_buffer= (uint) param->max_rows + 1;
@@ -1401,7 +1404,7 @@ bool check_if_pq_applicable(Sort_param *param,
   // Try to strip off addon fields.
   if (param->addon_field)
   {
-    const ulong row_length=
+    const size_t row_length=
       param->sort_length + param->ref_length + sizeof(char*);
     num_available_keys= memory_available / row_length;
 
@@ -1411,7 +1414,7 @@ bool check_if_pq_applicable(Sort_param *param,
       const double sort_merge_cost=
         get_merge_many_buffs_cost_fast(num_rows,
                                        num_available_keys,
-                                       row_length);
+                                       (uint)row_length);
       /*
         PQ has cost:
         (insert + qsort) * log(queue size) / TIME_FOR_COMPARE_ROWID +
@@ -1883,7 +1886,7 @@ Type_handler_string_result::sortlength(THD *thd,
   set_if_smaller(sortorder->length, thd->variables.max_sort_length);
   if (use_strnxfrm((cs= item->collation.collation)))
   {
-    sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
+    sortorder->length= (uint)cs->coll->strnxfrmlen(cs, sortorder->length);
   }
   else if (cs == &my_charset_bin)
   {
@@ -1966,7 +1969,7 @@ sortlength(THD *thd, SORT_FIELD *sortorder, uint s_length,
       if (use_strnxfrm((cs=sortorder->field->sort_charset())))
       {
         *multi_byte_charset= true;
-        sortorder->length= cs->coll->strnxfrmlen(cs, sortorder->length);
+        sortorder->length= (uint)cs->coll->strnxfrmlen(cs, sortorder->length);
       }
       if (sortorder->field->maybe_null())
 	length++;				// Place for NULL marker
diff --git a/sql/gcalc_slicescan.cc b/sql/gcalc_slicescan.cc
index da70daea4a8..ce1f4394ebd 100644
--- a/sql/gcalc_slicescan.cc
+++ b/sql/gcalc_slicescan.cc
@@ -137,13 +137,13 @@ static void GCALC_DBUG_PRINT_PI(const Gcalc_heap::Info *pi)
 static void GCALC_DBUG_PRINT_SLICE(const char *header,
                                    const Gcalc_scan_iterator::point *slice)
 {
-  int nbuf;
+  size_t nbuf;
   char buf[1024];
   nbuf= strlen(header);
   strcpy(buf, header);
   for (; slice; slice= slice->get_next())
   {
-    int lnbuf= nbuf;
+    size_t lnbuf= nbuf;
     lnbuf+= sprintf(buf + lnbuf, "%d\t", slice->thread);
     lnbuf+= sprintf(buf + lnbuf, "%s\t", gcalc_ev_name(slice->event));
 
@@ -170,7 +170,7 @@ static void GCALC_DBUG_PRINT_SLICE(const char *header,
 Gcalc_dyn_list::Gcalc_dyn_list(size_t blk_size, size_t sizeof_item):
   m_blk_size(blk_size - ALLOC_ROOT_MIN_BLOCK_SIZE),
   m_sizeof_item(ALIGN_SIZE(sizeof_item)),
-  m_points_per_blk((m_blk_size - PH_DATA_OFFSET) / m_sizeof_item),
+  m_points_per_blk((uint)((m_blk_size - PH_DATA_OFFSET) / m_sizeof_item)),
   m_blk_hook(&m_first_blk),
   m_free(NULL),
   m_keep(NULL)
diff --git a/sql/ha_partition.cc b/sql/ha_partition.cc
index 0df2c748ccc..12ec49f0e5a 100644
--- a/sql/ha_partition.cc
+++ b/sql/ha_partition.cc
@@ -1296,8 +1296,8 @@ bool print_admin_msg(THD* thd, uint len,
 {
   va_list args;
   Protocol *protocol= thd->protocol;
-  uint length;
-  uint msg_length;
+  size_t length;
+  size_t msg_length;
   char name[NAME_LEN*2+2];
   char *msgbuf;
   bool error= true;
@@ -1318,7 +1318,7 @@ bool print_admin_msg(THD* thd, uint len,
     goto err;
   }
 
-  length=(uint) (strxmov(name, db_name, ".", table_name.c_ptr_safe(), NullS) - name);
+  length=(size_t)(strxmov(name, db_name, ".", table_name.c_ptr_safe(), NullS) - name);
   /*
      TODO: switch from protocol to push_warning here. The main reason we didn't
      it yet is parallel repair, which threads have no THD object accessible via
@@ -2438,7 +2438,7 @@ reg_query_cache_dependant_table(THD *thd,
   (++(*block_table))->n= ++(*n);
   if (!cache->insert_table(thd, cache_key_len,
                            cache_key, (*block_table),
-                           table_share->db.length,
+                           (uint32) table_share->db.length,
                            (uint8) (cache_key_len -
                                     table_share->table_cache_key.length),
                            type,
@@ -2643,10 +2643,10 @@ static uint name_add(char *dest, const char *first_name, const char *sec_name)
 bool ha_partition::create_handler_file(const char *name)
 {
   partition_element *part_elem, *subpart_elem;
-  uint i, j, part_name_len, subpart_name_len;
-  uint tot_partition_words, tot_name_len, num_parts;
-  uint tot_parts= 0;
-  uint tot_len_words, tot_len_byte, chksum, tot_name_words;
+  size_t i, j, part_name_len, subpart_name_len;
+  size_t tot_partition_words, tot_name_len, num_parts;
+  size_t tot_parts= 0;
+  size_t tot_len_words, tot_len_byte, chksum, tot_name_words;
   char *name_buffer_ptr;
   uchar *file_buffer, *engine_array;
   bool result= TRUE;
@@ -2658,7 +2658,7 @@ bool ha_partition::create_handler_file(const char *name)
   DBUG_ENTER("create_handler_file");
 
   num_parts= m_part_info->partitions.elements;
-  DBUG_PRINT("enter", ("table name: %s  num_parts: %u", name, num_parts));
+  DBUG_PRINT("enter", ("table name: %s  num_parts: %zu", name, num_parts));
   tot_name_len= 0;
   for (i= 0; i < num_parts; i++)
   {
@@ -2777,7 +2777,7 @@ bool ha_partition::create_handler_file(const char *name)
     {
       uchar buffer[4];
       part_elem= part_it++;
-      uint length= part_elem->connect_string.length;
+      size_t length= part_elem->connect_string.length;
       int4store(buffer, length);
       if (my_write(file, buffer, 4, MYF(MY_WME | MY_NABP)) ||
           my_write(file, (uchar *) part_elem->connect_string.str, length,
@@ -3168,7 +3168,7 @@ bool ha_partition::insert_partition_name_in_hash(const char *name, uint part_id,
 {
   PART_NAME_DEF *part_def;
   uchar *part_name;
-  uint part_name_length;
+  size_t part_name_length;
   DBUG_ENTER("ha_partition::insert_partition_name_in_hash");
   /*
     Calculate and store the length here, to avoid doing it when
@@ -3188,7 +3188,7 @@ bool ha_partition::insert_partition_name_in_hash(const char *name, uint part_id,
     DBUG_RETURN(true);
   memcpy(part_name, name, part_name_length + 1);
   part_def->partition_name= part_name;
-  part_def->length= part_name_length;
+  part_def->length= (uint)part_name_length;
   part_def->part_id= part_id;
   part_def->is_subpart= is_subpart;
   if (my_hash_insert(&part_share->partition_name_hash, (uchar *) part_def))
@@ -5102,7 +5102,7 @@ end_dont_reset_start_part:
 void ha_partition::position(const uchar *record)
 {
   handler *file= m_file[m_last_part];
-  uint pad_length;
+  size_t pad_length;
   DBUG_ASSERT(bitmap_is_set(&(m_part_info->read_partitions), m_last_part));
   DBUG_ENTER("ha_partition::position");
 
@@ -5217,7 +5217,7 @@ bool ha_partition::init_record_priority_queue()
   */
   if (!m_ordered_rec_buffer)
   {
-    uint alloc_len;
+    size_t alloc_len;
     uint used_parts= bitmap_bits_set(&m_part_info->read_partitions);
     DBUG_ASSERT(used_parts > 0);
     /* Allocate record buffer for each used partition. */
diff --git a/sql/ha_partition.h b/sql/ha_partition.h
index 66a70348cfd..9ee767d89d4 100644
--- a/sql/ha_partition.h
+++ b/sql/ha_partition.h
@@ -263,7 +263,7 @@ private:
 
     underlying_table_rowid is only stored when the table has no extended keys.
   */
-  uint m_priority_queue_rec_len;
+  size_t m_priority_queue_rec_len;
 
   /*
     If true, then sorting records by key value also sorts them by their
diff --git a/sql/handler.cc b/sql/handler.cc
index db5a7b53684..75bc1985483 100644
--- a/sql/handler.cc
+++ b/sql/handler.cc
@@ -2607,7 +2607,7 @@ double handler::keyread_time(uint index, uint ranges, ha_rows rows)
     engines that support that (e.g. InnoDB) may want to overwrite this method.
     The model counts in the time to read index entries from cache.
   */
-  ulong len= table->key_info[index].key_length + ref_length;
+  size_t len= table->key_info[index].key_length + ref_length;
   if (index == table->s->primary_key && table->file->primary_key_is_clustered())
     len= table->s->stored_rec_length;
   double keys_per_block= (stats.block_size/2.0/len+1);
@@ -3989,7 +3989,7 @@ static bool update_frm_version(TABLE *table)
 
     int4store(version, MYSQL_VERSION_ID);
 
-    if ((result= mysql_file_pwrite(file, (uchar*) version, 4, 51L, MYF_RW)))
+    if ((result= (int)mysql_file_pwrite(file, (uchar*) version, 4, 51L, MYF_RW)))
       goto err;
 
     table->s->mysql_version= MYSQL_VERSION_ID;
@@ -4770,7 +4770,7 @@ void handler::update_global_table_stats()
     }
     memcpy(table_stats->table, table->s->table_cache_key.str,
            table->s->table_cache_key.length);
-    table_stats->table_name_length= table->s->table_cache_key.length;
+    table_stats->table_name_length= (uint)table->s->table_cache_key.length;
     table_stats->engine_type= ht->db_type;
     /* No need to set variables to 0, as we use MY_ZEROFILL above */
 
@@ -4813,7 +4813,7 @@ void handler::update_global_index_stats()
     if (index_rows_read[index])
     {
       INDEX_STATS* index_stats;
-      uint key_length;
+      size_t key_length;
       KEY *key_info = &table->key_info[index];  // Rows were read using this
 
       DBUG_ASSERT(key_info->cache_name);
@@ -4914,8 +4914,8 @@ int ha_create_table(THD *thd, const char *path,
     if (!thd->is_error())
       my_error(ER_CANT_CREATE_TABLE, MYF(0), db, table_name, error);
     table.file->print_error(error, MYF(ME_JUST_WARNING));
-    PSI_CALL_drop_table_share(temp_table, share.db.str, share.db.length,
-                              share.table_name.str, share.table_name.length);
+    PSI_CALL_drop_table_share(temp_table, share.db.str, (uint)share.db.length,
+                              share.table_name.str, (uint)share.table_name.length);
   }
 
   (void) closefrm(&table);
@@ -5426,7 +5426,7 @@ static my_bool discover_names(THD *thd, plugin_ref plugin,
 
   if (ht->state == SHOW_OPTION_YES && ht->discover_table_names)
   {
-    uint old_elements= args->result->tables->elements();
+    size_t old_elements= args->result->tables->elements();
     if (ht->discover_table_names(ht, args->db, args->dirp, args->result))
       return 1;
 
@@ -5435,7 +5435,7 @@ static my_bool discover_names(THD *thd, plugin_ref plugin,
       a corresponding .frm file; but custom engine discover methods might
     */
     if (ht->discover_table_names != hton_ext_based_table_discovery)
-      args->possible_duplicates+= args->result->tables->elements() - old_elements;
+      args->possible_duplicates+= (uint)(args->result->tables->elements() - old_elements);
   }
 
   return 0;
@@ -6739,7 +6739,7 @@ bool HA_CREATE_INFO::check_conflicting_charset_declarations(CHARSET_INFO *cs)
 /* Remove all indexes for a given table from global index statistics */
 
 static
-int del_global_index_stats_for_table(THD *thd, uchar* cache_key, uint cache_key_length)
+int del_global_index_stats_for_table(THD *thd, uchar* cache_key, size_t cache_key_length)
 {
   int res = 0;
   DBUG_ENTER("del_global_index_stats_for_table");
@@ -6780,7 +6780,7 @@ int del_global_table_stat(THD *thd, LEX_CSTRING *db, LEX_CSTRING *table)
   TABLE_STATS *table_stats;
   int res = 0;
   uchar *cache_key;
-  uint cache_key_length;
+  size_t cache_key_length;
   DBUG_ENTER("del_global_table_stat");
 
   cache_key_length= db->length + 1 + table->length + 1;
@@ -6817,7 +6817,7 @@ end:
 int del_global_index_stat(THD *thd, TABLE* table, KEY* key_info)
 {
   INDEX_STATS *index_stats;
-  uint key_length= table->s->table_cache_key.length + key_info->name.length + 1;
+  size_t key_length= table->s->table_cache_key.length + key_info->name.length + 1;
   int res = 0;
   DBUG_ENTER("del_global_index_stat");
   mysql_mutex_lock(&LOCK_global_index_stats);
diff --git a/sql/hostname.cc b/sql/hostname.cc
index 0e60dde893c..56bd407f1dd 100644
--- a/sql/hostname.cc
+++ b/sql/hostname.cc
@@ -180,7 +180,7 @@ void hostname_cache_unlock()
 static void prepare_hostname_cache_key(const char *ip_string,
                                        char *ip_key)
 {
-  int ip_string_length= strlen(ip_string);
+  size_t ip_string_length= strlen(ip_string);
   DBUG_ASSERT(ip_string_length < HOST_ENTRY_KEY_SIZE);
 
   memset(ip_key, 0, HOST_ENTRY_KEY_SIZE);
@@ -229,12 +229,12 @@ static void add_hostname_impl(const char *ip_key, const char *hostname,
   {
     if (hostname != NULL)
     {
-      uint len= strlen(hostname);
+      size_t len= strlen(hostname);
       if (len > sizeof(entry->m_hostname) - 1)
         len= sizeof(entry->m_hostname) - 1;
       memcpy(entry->m_hostname, hostname, len);
       entry->m_hostname[len]= '\0';
-      entry->m_hostname_length= len;
+      entry->m_hostname_length= (uint)len;
 
       DBUG_PRINT("info",
                  ("Adding/Updating '%s' -> '%s' (validated) to the hostname cache...'",
@@ -946,7 +946,7 @@ int ip_to_hostname(struct sockaddr_storage *ip_storage,
 
     {
       err_status=
-        vio_get_normalized_ip_string(addr_info->ai_addr, addr_info->ai_addrlen,
+        vio_get_normalized_ip_string(addr_info->ai_addr, (int)addr_info->ai_addrlen,
                                      ip_buffer, sizeof (ip_buffer));
       DBUG_ASSERT(!err_status);
     }
@@ -990,7 +990,7 @@ int ip_to_hostname(struct sockaddr_storage *ip_storage,
       char ip_buffer[HOST_ENTRY_KEY_SIZE];
 
       err_status=
-        vio_get_normalized_ip_string(addr_info->ai_addr, addr_info->ai_addrlen,
+        vio_get_normalized_ip_string(addr_info->ai_addr, (int)addr_info->ai_addrlen,
                                      ip_buffer, sizeof (ip_buffer));
       DBUG_ASSERT(!err_status);
 
diff --git a/sql/innodb_priv.h b/sql/innodb_priv.h
index 27aa9ac8645..7fbaa7cfc2f 100644
--- a/sql/innodb_priv.h
+++ b/sql/innodb_priv.h
@@ -22,11 +22,11 @@
 
 class THD;
 
-int get_quote_char_for_identifier(THD *thd, const char *name, uint length);
+int get_quote_char_for_identifier(THD *thd, const char *name, size_t length);
 bool schema_table_store_record(THD *thd, TABLE *table);
 void localtime_to_TIME(MYSQL_TIME *to, struct tm *from);
-uint strconvert(CHARSET_INFO *from_cs, const char *from, uint from_length,
-                CHARSET_INFO *to_cs, char *to, uint to_length,
+uint strconvert(CHARSET_INFO *from_cs, const char *from, size_t from_length,
+                CHARSET_INFO *to_cs, char *to, size_t to_length,
                 uint *errors);
 
 void sql_print_error(const char *format, ...);
diff --git a/sql/item.cc b/sql/item.cc
index b36c1518eb8..d33903a3803 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -1172,7 +1172,7 @@ bool Item::check_type_scalar(const char *opname) const
 }
 
 
-void Item::set_name(THD *thd, const char *str, uint length, CHARSET_INFO *cs)
+void Item::set_name(THD *thd, const char *str, size_t length, CHARSET_INFO *cs)
 {
   if (!length)
   {
@@ -2757,7 +2757,7 @@ const char *
 Item_sp::func_name(THD *thd) const
 {
   /* Calculate length to avoid reallocation of string for sure */
-  uint len= (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
+  size_t len= (((m_name->m_explicit_name ? m_name->m_db.length : 0) +
               m_name->m_name.length)*2 + //characters*quoting
              2 +                         // ` and `
              (m_name->m_explicit_name ?
@@ -3609,7 +3609,7 @@ longlong Item_field::val_int_endpoint(bool left_endp, bool *incl_endp)
   This is always 'signed'. Unsigned values are created with Item_uint()
 */
 
-Item_int::Item_int(THD *thd, const char *str_arg, uint length):
+Item_int::Item_int(THD *thd, const char *str_arg, size_t length):
   Item_num(thd)
 {
   char *end_ptr= (char*) str_arg + length;
@@ -3656,7 +3656,7 @@ Item *Item_bool::neg_transformer(THD *thd)
 }
 
 
-Item_uint::Item_uint(THD *thd, const char *str_arg, uint length):
+Item_uint::Item_uint(THD *thd, const char *str_arg, size_t length):
   Item_int(thd, str_arg, length)
 {
   unsigned_flag= 1;
@@ -3687,7 +3687,7 @@ void Item_uint::print(String *str, enum_query_type query_type)
 }
 
 
-Item_decimal::Item_decimal(THD *thd, const char *str_arg, uint length,
+Item_decimal::Item_decimal(THD *thd, const char *str_arg, size_t length,
                            CHARSET_INFO *charset):
   Item_num(thd)
 {
@@ -7102,7 +7102,7 @@ static uint nr_of_decimals(const char *str, const char *end)
   Item->name should be fixed to use LEX_STRING eventually.
 */
 
-Item_float::Item_float(THD *thd, const char *str_arg, uint length):
+Item_float::Item_float(THD *thd, const char *str_arg, size_t length):
   Item_num(thd)
 {
   int error;
@@ -7112,13 +7112,13 @@ Item_float::Item_float(THD *thd, const char *str_arg, uint length):
   if (error)
   {
     char tmp[NAME_LEN + 1];
-    my_snprintf(tmp, sizeof(tmp), "%.*s", length, str_arg);
+    my_snprintf(tmp, sizeof(tmp), "%.*s", (int)length, str_arg);
     my_error(ER_ILLEGAL_VALUE_FOR_TYPE, MYF(0), "double", tmp);
   }
   presentation= name.str= str_arg;
   name.length= strlen(str_arg);
   decimals=(uint8) nr_of_decimals(str_arg, str_arg+length);
-  max_length=length;
+  max_length=(uint32)length;
   fixed= 1;
 }
 
@@ -7155,10 +7155,9 @@ inline uint char_val(char X)
 }
 
 
-void Item_hex_constant::hex_string_init(THD *thd, const char *str,
-                                        uint str_length)
+void Item_hex_constant::hex_string_init(THD *thd, const char *str, size_t str_length)
 {
-  max_length=(str_length+1)/2;
+  max_length=(uint)((str_length+1)/2);
   char *ptr=(char*) thd->alloc(max_length+1);
   if (!ptr)
   {
@@ -7220,7 +7219,7 @@ void Item_hex_string::print(String *str, enum_query_type query_type)
   In number context this is a longlong value.
 */
   
-Item_bin_string::Item_bin_string(THD *thd, const char *str, uint str_length):
+Item_bin_string::Item_bin_string(THD *thd, const char *str, size_t str_length):
   Item_hex_hybrid(thd)
 {
   const char *end= str + str_length - 1;
@@ -7228,7 +7227,7 @@ Item_bin_string::Item_bin_string(THD *thd, const char *str, uint str_length):
   uchar bits= 0;
   uint power= 1;
 
-  max_length= (str_length + 7) >> 3;
+  max_length= (uint)((str_length + 7) >> 3);
   if (!(ptr= (char*) thd->alloc(max_length + 1)))
     return;
   str_value.set(ptr, max_length, &my_charset_bin);
diff --git a/sql/item.h b/sql/item.h
index 82dfa3f8930..9f1307da576 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -740,7 +740,7 @@ public:
     name.length= 0;
 #endif
   }		/*lint -e1509 */
-  void set_name(THD *thd, const char *str, uint length, CHARSET_INFO *cs);
+  void set_name(THD *thd, const char *str, size_t length, CHARSET_INFO *cs);
   void set_name_no_truncate(THD *thd, const char *str, uint length,
                             CHARSET_INFO *cs);
   void init_make_field(Send_field *tmp_field,enum enum_field_types type);
@@ -3476,31 +3476,31 @@ class Item_int :public Item_num
 {
 public:
   longlong value;
-  Item_int(THD *thd, int32 i,uint length= MY_INT32_NUM_DECIMAL_DIGITS):
+  Item_int(THD *thd, int32 i,size_t length= MY_INT32_NUM_DECIMAL_DIGITS):
     Item_num(thd), value((longlong) i)
-    { max_length=length; fixed= 1; }
-  Item_int(THD *thd, longlong i,uint length= MY_INT64_NUM_DECIMAL_DIGITS):
+    { max_length=(uint32)length; fixed= 1; }
+  Item_int(THD *thd, longlong i,size_t length= MY_INT64_NUM_DECIMAL_DIGITS):
     Item_num(thd), value(i)
-    { max_length=length; fixed= 1; }
-  Item_int(THD *thd, ulonglong i, uint length= MY_INT64_NUM_DECIMAL_DIGITS):
+    { max_length=(uint32)length; fixed= 1; }
+  Item_int(THD *thd, ulonglong i, size_t length= MY_INT64_NUM_DECIMAL_DIGITS):
     Item_num(thd), value((longlong)i)
-    { max_length=length; fixed= 1; unsigned_flag= 1; }
-  Item_int(THD *thd, const char *str_arg,longlong i,uint length):
+    { max_length=(uint32)length; fixed= 1; unsigned_flag= 1; }
+  Item_int(THD *thd, const char *str_arg,longlong i,size_t length):
     Item_num(thd), value(i)
     {
-      max_length=length;
+      max_length=(uint32)length;
       name.str= str_arg; name.length= safe_strlen(name.str);
       fixed= 1;
     }
-  Item_int(THD *thd, const char *str_arg,longlong i,uint length, bool flag):
+  Item_int(THD *thd, const char *str_arg,longlong i,size_t length, bool flag):
     Item_num(thd), value(i)
     {
-      max_length=length;
+      max_length=(uint32)length;
       name.str= str_arg; name.length= safe_strlen(name.str);
       fixed= 1;
       unsigned_flag= flag;
     }
-  Item_int(THD *thd, const char *str_arg, uint length=64);
+  Item_int(THD *thd, const char *str_arg, size_t length=64);
   enum Type type() const { return INT_ITEM; }
   const Type_handler *type_handler() const
   { return type_handler_long_or_longlong(); }
@@ -3545,7 +3545,7 @@ public:
 class Item_uint :public Item_int
 {
 public:
-  Item_uint(THD *thd, const char *str_arg, uint length);
+  Item_uint(THD *thd, const char *str_arg, size_t length);
   Item_uint(THD *thd, ulonglong i): Item_int(thd, i, 10) {}
   Item_uint(THD *thd, const char *str_arg, longlong i, uint length);
   double val_real()
@@ -3579,7 +3579,7 @@ class Item_decimal :public Item_num
 protected:
   my_decimal decimal_value;
 public:
-  Item_decimal(THD *thd, const char *str_arg, uint length,
+  Item_decimal(THD *thd, const char *str_arg, size_t length,
                CHARSET_INFO *charset);
   Item_decimal(THD *thd, const char *str, const my_decimal *val_arg,
                uint decimal_par, uint length);
@@ -3612,7 +3612,7 @@ class Item_float :public Item_num
   const char *presentation;
 public:
   double value;
-  Item_float(THD *thd, const char *str_arg, uint length);
+  Item_float(THD *thd, const char *str_arg, size_t length);
   Item_float(THD *thd, const char *str, double val_arg, uint decimal_par,
              uint length): Item_num(thd), value(val_arg)
   {
@@ -3723,7 +3723,7 @@ public:
     str_value.set_or_copy_aligned(str, length, cs);
     fix_and_set_name_from_value(thd, dv, Metadata(&str_value, repertoire));
   }
-  Item_string(THD *thd, const char *str, uint length,
+  Item_string(THD *thd, const char *str, size_t length,
               CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE):
     Item_basic_constant(thd)
   {
@@ -3739,21 +3739,21 @@ public:
     fix_and_set_name_from_value(thd, dv, Metadata(&str_value, repertoire));
   }
   // Constructors with an externally provided item name
-  Item_string(THD *thd, const char *name_par, const char *str, uint length,
+  Item_string(THD *thd, const char *name_par, const char *str, size_t length,
               CHARSET_INFO *cs, Derivation dv= DERIVATION_COERCIBLE):
     Item_basic_constant(thd)
   {
     str_value.set_or_copy_aligned(str, length, cs);
     fix_from_value(dv, Metadata(&str_value));
-    set_name(thd, name_par, (uint) safe_strlen(name_par), system_charset_info);
+    set_name(thd, name_par,safe_strlen(name_par), system_charset_info);
   }
-  Item_string(THD *thd, const char *name_par, const char *str, uint length,
+  Item_string(THD *thd, const char *name_par, const char *str, size_t length,
               CHARSET_INFO *cs, Derivation dv, uint repertoire):
     Item_basic_constant(thd)
   {
     str_value.set_or_copy_aligned(str, length, cs);
     fix_from_value(dv, Metadata(&str_value, repertoire));
-    set_name(thd, name_par, (uint) safe_strlen(name_par), system_charset_info);
+    set_name(thd, name_par, safe_strlen(name_par), system_charset_info);
   }
   void print_value(String *to) const
   {
@@ -4029,13 +4029,13 @@ public:
 class Item_hex_constant: public Item_basic_constant
 {
 private:
-  void hex_string_init(THD *thd, const char *str, uint str_length);
+  void hex_string_init(THD *thd, const char *str, size_t str_length);
 public:
   Item_hex_constant(THD *thd): Item_basic_constant(thd)
   {
     hex_string_init(thd, "", 0);
   }
-  Item_hex_constant(THD *thd, const char *str, uint str_length):
+  Item_hex_constant(THD *thd, const char *str, size_t str_length):
     Item_basic_constant(thd)
   {
     hex_string_init(thd, str, str_length);
@@ -4067,7 +4067,7 @@ class Item_hex_hybrid: public Item_hex_constant
 {
 public:
   Item_hex_hybrid(THD *thd): Item_hex_constant(thd) {}
-  Item_hex_hybrid(THD *thd, const char *str, uint str_length):
+  Item_hex_hybrid(THD *thd, const char *str, size_t str_length):
     Item_hex_constant(thd, str, str_length) {}
   uint decimal_precision() const;
   double val_real()
@@ -4117,7 +4117,7 @@ class Item_hex_string: public Item_hex_constant
 {
 public:
   Item_hex_string(THD *thd): Item_hex_constant(thd) {}
-  Item_hex_string(THD *thd, const char *str, uint str_length):
+  Item_hex_string(THD *thd, const char *str, size_t str_length):
     Item_hex_constant(thd, str, str_length) {}
   longlong val_int()
   {
@@ -4148,7 +4148,7 @@ public:
 class Item_bin_string: public Item_hex_hybrid
 {
 public:
-  Item_bin_string(THD *thd, const char *str,uint str_length);
+  Item_bin_string(THD *thd, const char *str, size_t str_length);
 };
 
 
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 780c60e4eb3..26c021f96b5 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -5603,9 +5603,9 @@ int Regexp_processor_pcre::pcre_exec_with_warn(const pcre *code,
 }
 
 
-bool Regexp_processor_pcre::exec(const char *str, int length, int offset)
+bool Regexp_processor_pcre::exec(const char *str, size_t length, size_t offset)
 {
-  m_pcre_exec_rc= pcre_exec_with_warn(m_pcre, &m_pcre_extra, str, length, offset, 0,
+  m_pcre_exec_rc= pcre_exec_with_warn(m_pcre, &m_pcre_extra, str, (int)length, (int)offset, 0,
                                       m_SubStrVec, array_elements(m_SubStrVec));
   return false;
 }
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 8b47f09497f..9392b51e69b 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -2766,7 +2766,7 @@ public:
   {
     return !m_is_const && compile(item, false);
   }
-  bool exec(const char *str, int length, int offset);
+  bool exec(const char *str, size_t length, size_t offset);
   bool exec(String *str, int offset, uint n_result_offsets_to_convert);
   bool exec(Item *item, int offset, uint n_result_offsets_to_convert);
   bool match() const { return m_pcre_exec_rc < 0 ? 0 : 1; }
diff --git a/sql/item_create.cc b/sql/item_create.cc
index 7a623c5d77b..548ce3bac94 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -3284,7 +3284,7 @@ Create_udf_func Create_udf_func::s_singleton;
 Item*
 Create_udf_func::create_func(THD *thd, LEX_CSTRING *name, List<Item> *item_list)
 {
-  udf_func *udf= find_udf(name->str, (uint) name->length);
+  udf_func *udf= find_udf(name->str,  name->length);
   DBUG_ASSERT(udf);
   return create(thd, udf, item_list);
 }
@@ -7276,7 +7276,7 @@ have_important_literal_warnings(const MYSQL_TIME_STATUS *status)
 */
 
 Item *create_temporal_literal(THD *thd,
-                              const char *str, uint length,
+                              const char *str, size_t length,
                               CHARSET_INFO *cs,
                               enum_field_types type,
                               bool send_error)
diff --git a/sql/item_create.h b/sql/item_create.h
index b27946cfa46..5983a092cdc 100644
--- a/sql/item_create.h
+++ b/sql/item_create.h
@@ -192,7 +192,7 @@ protected:
 
 
 Item *create_temporal_literal(THD *thd,
-                              const char *str, uint length,
+                              const char *str, size_t length,
                               CHARSET_INFO *cs,
                               enum_field_types type,
                               bool send_error);
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 3583b6aed62..3796beebc13 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -3204,7 +3204,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
   if (check_stack_overrun(thd, STACK_MIN_SIZE, buff))
     DBUG_RETURN(TRUE);				// Fatal error flag is set!
 
-  udf_func *tmp_udf=find_udf(u_d->name.str,(uint) u_d->name.length,1);
+  udf_func *tmp_udf=find_udf(u_d->name.str,u_d->name.length,1);
 
   if (!tmp_udf)
   {
@@ -3299,7 +3299,7 @@ udf_handler::fix_fields(THD *thd, Item_func_or_sum *func,
       f_args.lengths[i]= arguments[i]->max_length;
       f_args.maybe_null[i]= (char) arguments[i]->maybe_null;
       f_args.attributes[i]= arguments[i]->name.str;
-      f_args.attribute_lengths[i]= arguments[i]->name.length;
+      f_args.attribute_lengths[i]= (ulong)arguments[i]->name.length;
 
       if (arguments[i]->const_item())
       {
@@ -4386,7 +4386,7 @@ user_var_entry *get_variable(HASH *hash, LEX_CSTRING *name,
                                                  name->length)) &&
       create_if_not_exists)
   {
-    uint size=ALIGN_SIZE(sizeof(user_var_entry))+name->length+1+extra_size;
+    size_t size=ALIGN_SIZE(sizeof(user_var_entry))+name->length+1+extra_size;
     if (!my_hash_inited(hash))
       return 0;
     if (!(entry = (user_var_entry*) my_malloc(size,
@@ -4607,7 +4607,7 @@ bool Item_func_set_user_var::register_field_in_bitmap(void *arg)
 */
 
 static bool
-update_hash(user_var_entry *entry, bool set_null, void *ptr, uint length,
+update_hash(user_var_entry *entry, bool set_null, void *ptr, size_t length,
             Item_result type, CHARSET_INFO *cs,
             bool unsigned_arg)
 {
@@ -4668,7 +4668,7 @@ update_hash(user_var_entry *entry, bool set_null, void *ptr, uint length,
 
 
 bool
-Item_func_set_user_var::update_hash(void *ptr, uint length,
+Item_func_set_user_var::update_hash(void *ptr, size_t length,
                                     Item_result res_type,
                                     CHARSET_INFO *cs,
                                     bool unsigned_arg)
@@ -5332,7 +5332,7 @@ get_var_with_binlog(THD *thd, enum_sql_command sql_command,
     return 0;
   }
 
-  uint size;
+  size_t size;
   /*
     First we need to store value of var_entry, when the next situation
     appears:
@@ -5399,7 +5399,7 @@ void Item_func_get_user_var::fix_length_and_dec()
   if (!error && m_var_entry)
   {
     unsigned_flag= m_var_entry->unsigned_flag;
-    max_length= m_var_entry->length;
+    max_length= (uint32)m_var_entry->length;
     collation.set(m_var_entry->charset(), DERIVATION_IMPLICIT);
     set_handler_by_result_type(m_var_entry->type);
     switch (result_type()) {
@@ -5613,7 +5613,7 @@ void Item_func_get_system_var::fix_length_and_dec()
         (char*) var->value_ptr(current_thd, var_type, &component) :
         *(char**) var->value_ptr(current_thd, var_type, &component);
       if (cptr)
-        max_length= system_charset_info->cset->numchars(system_charset_info,
+        max_length= (uint32)system_charset_info->cset->numchars(system_charset_info,
                                                         cptr,
                                                         cptr + strlen(cptr));
       mysql_mutex_unlock(&LOCK_global_system_variables);
@@ -5625,7 +5625,7 @@ void Item_func_get_system_var::fix_length_and_dec()
       {
         mysql_mutex_lock(&LOCK_global_system_variables);
         LEX_STRING *ls= ((LEX_STRING*)var->value_ptr(current_thd, var_type, &component));
-        max_length= system_charset_info->cset->numchars(system_charset_info,
+        max_length= (uint32)system_charset_info->cset->numchars(system_charset_info,
                                                         ls->str,
                                                         ls->str + ls->length);
         mysql_mutex_unlock(&LOCK_global_system_variables);
diff --git a/sql/item_func.h b/sql/item_func.h
index 1f942ab1b55..536fe1bd5a7 100644
--- a/sql/item_func.h
+++ b/sql/item_func.h
@@ -2407,7 +2407,7 @@ public:
   String *str_result(String *str);
   my_decimal *val_decimal_result(my_decimal *);
   bool is_null_result();
-  bool update_hash(void *ptr, uint length, enum Item_result type,
+  bool update_hash(void *ptr, size_t length, enum Item_result type,
                    CHARSET_INFO *cs, bool unsigned_arg);
   bool send(Protocol *protocol, st_value *buffer);
   void make_field(THD *thd, Send_field *tmp_field);
@@ -2493,7 +2493,7 @@ public:
   {
     DBUG_ASSERT(a->length < UINT_MAX32);
     org_name= *a;
-    set_name(thd, a->str, (uint) a->length, system_charset_info);
+    set_name(thd, a->str, a->length, system_charset_info);
   }
   /* We should return something different from FIELD_ITEM here */
   enum Type type() const { return STRING_ITEM;}
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index c768f7d9d1a..e342b6d5fb7 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -527,14 +527,14 @@ String *Item_func_decode_histogram::val_str(String *str)
       DBUG_ASSERT(0);
     }
     /* show delta with previous value */
-    int size= my_snprintf(numbuf, sizeof(numbuf),
+    size_t size= my_snprintf(numbuf, sizeof(numbuf),
                           representation_by_type[type], val - prev);
     str->append(numbuf, size);
     str->append(",");
     prev= val;
   }
   /* show delta with max */
-  int size= my_snprintf(numbuf, sizeof(numbuf),
+  size_t size= my_snprintf(numbuf, sizeof(numbuf),
                         representation_by_type[type], 1.0 - prev);
   str->append(numbuf, size);
 
@@ -1651,7 +1651,7 @@ String *Item_str_conv::val_str(String *str)
   null_value=0;
   if (multiply == 1)
   {
-    uint len;
+    size_t len;
     res= copy_if_not_alloced(&tmp_value, res, res->length());
     len= converter(collation.collation, (char*) res->ptr(), res->length(),
                                         (char*) res->ptr(), res->length());
@@ -1660,7 +1660,7 @@ String *Item_str_conv::val_str(String *str)
   }
   else
   {
-    uint len= res->length() * multiply;
+    size_t len= res->length() * multiply;
     tmp_value.alloc(len);
     tmp_value.set_charset(collation.collation);
     len= converter(collation.collation, (char*) res->ptr(), res->length(),
@@ -3618,10 +3618,10 @@ void Item_func_weight_string::fix_length_and_dec()
   */
   if (!(max_length= result_length))
   {
-    uint char_length;
+    size_t char_length;
     char_length= ((cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS) || !nweights) ?
                  args[0]->max_char_length() : nweights * cs->levels_for_order;
-    max_length= cs->coll->strnxfrmlen(cs, char_length * cs->mbmaxlen);
+    max_length= (uint32)cs->coll->strnxfrmlen(cs, char_length * cs->mbmaxlen);
   }
   maybe_null= 1;
 }
@@ -3632,7 +3632,7 @@ String *Item_func_weight_string::val_str(String *str)
 {
   String *res;
   CHARSET_INFO *cs= args[0]->collation.collation;
-  uint tmp_length, frm_length;
+  size_t tmp_length, frm_length;
   DBUG_ASSERT(fixed == 1);
 
   if (args[0]->result_type() != STRING_RESULT ||
@@ -3646,7 +3646,7 @@ String *Item_func_weight_string::val_str(String *str)
   */
   if (!(tmp_length= result_length))
   {
-    uint char_length;
+    size_t char_length;
     if (cs->state & MY_CS_STRNXFRM_BAD_NWEIGHTS)
     {
       /*
@@ -3692,7 +3692,7 @@ String *Item_func_weight_string::val_str(String *str)
 
   frm_length= cs->coll->strnxfrm(cs,
                                  (uchar *) str->ptr(), tmp_length,
-                                 nweights ? nweights : tmp_length,
+                                 nweights ? nweights : (uint)tmp_length,
                                  (const uchar *) res->ptr(), res->length(),
                                  flags);
   DBUG_ASSERT(frm_length <= tmp_length);
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 354fd4cbf1a..bcc75131d02 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -3098,7 +3098,7 @@ bool Item_exists_subselect::exists2in_processor(void *opt_arg)
                                            new (thd->mem_root)
                                            Item_direct_ref(thd,
                                                            &unit->outer_select()->context,
-                                                           optimizer->arguments()[0]->addr(i),
+                                                           optimizer->arguments()[0]->addr((int)i),
                                                            (char *)"<no matter>",
                                                            &exists_outer_expr_name)),
                        thd->mem_root);
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 692d6bf9697..25a0f68f575 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -3597,7 +3597,7 @@ int dump_leaf_key(void* key_arg, element_count count __attribute__((unused)),
       as this is never used to limit the length of the data.
       Cut is done with the third argument.
     */
-    uint add_length= Well_formed_prefix(cs,
+    size_t add_length= Well_formed_prefix(cs,
                                         ptr + old_length,
                                         ptr + max_length,
                                         result->length()).length();
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index ed4b2839170..a048f4d933d 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -709,8 +709,7 @@ static bool make_date_time(DATE_TIME_FORMAT *format, MYSQL_TIME *l_time,
                          For example, '1.1' -> '1.100000'
 */
 
-static bool get_interval_info(const char *str,uint length,CHARSET_INFO *cs,
-                              uint count, ulonglong *values,
+static bool get_interval_info(const char *str, size_t length,CHARSET_INFO *cs, size_t count, ulonglong *values,
                               bool transform_msec)
 {
   const char *end=str+length;
@@ -2427,7 +2426,7 @@ void Item_char_typecast::print(String *str, enum_query_type query_type)
 }
 
 
-void Item_char_typecast::check_truncation_with_warn(String *src, uint dstlen)
+void Item_char_typecast::check_truncation_with_warn(String *src, size_t dstlen)
 {
   if (dstlen < src->length())
   {
@@ -2448,7 +2447,7 @@ void Item_char_typecast::check_truncation_with_warn(String *src, uint dstlen)
 }
 
 
-String *Item_char_typecast::reuse(String *src, uint32 length)
+String *Item_char_typecast::reuse(String *src, size_t length)
 {
   DBUG_ASSERT(length <= src->length());
   check_truncation_with_warn(src, length);
diff --git a/sql/item_timefunc.h b/sql/item_timefunc.h
index 878179105be..744cdb388b0 100644
--- a/sql/item_timefunc.h
+++ b/sql/item_timefunc.h
@@ -1091,10 +1091,10 @@ class Item_char_typecast :public Item_str_func
   String tmp_value;
   bool m_suppress_warning_to_error_escalation;
   bool has_explicit_length() const { return cast_length != ~0U; }
-  String *reuse(String *src, uint32 length);
+  String *reuse(String *src, size_t length);
   String *copy(String *src, CHARSET_INFO *cs);
   uint adjusted_length_with_warn(uint length);
-  void check_truncation_with_warn(String *src, uint dstlen);
+  void check_truncation_with_warn(String *src, size_t dstlen);
   void fix_length_and_dec_internal(CHARSET_INFO *fromcs);
 public:
   Item_char_typecast(THD *thd, Item *a, uint length_arg, CHARSET_INFO *cs_arg):
diff --git a/sql/key.cc b/sql/key.cc
index ab93e8a0437..93500633d08 100644
--- a/sql/key.cc
+++ b/sql/key.cc
@@ -317,7 +317,7 @@ bool key_cmp_if_same(TABLE *table,const uchar *key,uint idx,uint key_length)
                                 FIELDFLAG_PACK)))
     {
       CHARSET_INFO *cs= key_part->field->charset();
-      uint char_length= key_part->length / cs->mbmaxlen;
+      size_t char_length= key_part->length / cs->mbmaxlen;
       const uchar *pos= table->record[0] + key_part->offset;
       if (length > char_length)
       {
@@ -383,7 +383,7 @@ void field_unpack(String *to, Field *field, const uchar *rec, uint max_length,
         which can break a multi-byte characters in the middle.
         Align, returning not more than "char_length" characters.
       */
-      uint charpos, char_length= max_length / cs->mbmaxlen;
+      size_t charpos, char_length= max_length / cs->mbmaxlen;
       if ((charpos= my_charpos(cs, tmp.ptr(),
                                tmp.ptr() + tmp.length(),
                                char_length)) < tmp.length())
@@ -695,7 +695,7 @@ ulong key_hashnr(KEY *key_info, uint used_key_parts, const uchar *key)
   {
     uchar *pos= (uchar*)key;
     CHARSET_INFO *UNINIT_VAR(cs);
-    uint UNINIT_VAR(length), UNINIT_VAR(pack_length);
+    size_t UNINIT_VAR(length), UNINIT_VAR(pack_length);
     bool is_string= TRUE;
 
     key+= key_part->length;
@@ -752,7 +752,7 @@ ulong key_hashnr(KEY *key_info, uint used_key_parts, const uchar *key)
     {
       if (cs->mbmaxlen > 1)
       {
-        uint char_length= my_charpos(cs, pos + pack_length,
+        size_t char_length= my_charpos(cs, pos + pack_length,
                                      pos + pack_length + length,
                                      length / cs->mbmaxlen);
         set_if_smaller(length, char_length);
@@ -799,7 +799,7 @@ bool key_buf_cmp(KEY *key_info, uint used_key_parts,
     uchar *pos1= (uchar*)key1;
     uchar *pos2= (uchar*)key2;
     CHARSET_INFO *UNINIT_VAR(cs);
-    uint UNINIT_VAR(length1), UNINIT_VAR(length2), UNINIT_VAR(pack_length);
+    size_t UNINIT_VAR(length1), UNINIT_VAR(length2), UNINIT_VAR(pack_length);
     bool is_string= TRUE;
 
     key1+= key_part->length;
@@ -863,13 +863,13 @@ bool key_buf_cmp(KEY *key_info, uint used_key_parts,
         Compare the strings taking into account length in characters
         and collation
       */
-      uint byte_len1= length1, byte_len2= length2;
+      size_t byte_len1= length1, byte_len2= length2;
       if (cs->mbmaxlen > 1)
       {
-        uint char_length1= my_charpos(cs, pos1 + pack_length,
+        size_t char_length1= my_charpos(cs, pos1 + pack_length,
                                       pos1 + pack_length + length1,
                                       length1 / cs->mbmaxlen);
-        uint char_length2= my_charpos(cs, pos2 + pack_length,
+        size_t char_length2= my_charpos(cs, pos2 + pack_length,
                                       pos2 + pack_length + length2,
                                       length2 / cs->mbmaxlen);
         set_if_smaller(length1, char_length1);
diff --git a/sql/keycaches.cc b/sql/keycaches.cc
index 6bfdb34157e..9db51ee1801 100644
--- a/sql/keycaches.cc
+++ b/sql/keycaches.cc
@@ -30,17 +30,17 @@ class NAMED_ILINK :public ilink
 {
 public:
   const char *name;
-  uint name_length;
+  size_t name_length;
   uchar* data;
 
   NAMED_ILINK(I_List<NAMED_ILINK> *links, const char *name_arg,
-             uint name_length_arg, uchar* data_arg)
+             size_t name_length_arg, uchar* data_arg)
     :name_length(name_length_arg), data(data_arg)
   {
     name= my_strndup(name_arg, name_length, MYF(MY_WME));
     links->push_back(this);
   }
-  inline bool cmp(const char *name_cmp, uint length)
+  inline bool cmp(const char *name_cmp, size_t length)
   {
     return length == name_length && !memcmp(name, name_cmp, length);
   }
@@ -50,7 +50,7 @@ public:
   }
 };
 
-uchar* find_named(I_List<NAMED_ILINK> *list, const char *name, uint length,
+uchar* find_named(I_List<NAMED_ILINK> *list, const char *name, size_t length,
                 NAMED_ILINK **found)
 {
   I_List_iterator<NAMED_ILINK> it(*list);
@@ -68,7 +68,7 @@ uchar* find_named(I_List<NAMED_ILINK> *list, const char *name, uint length,
 }
 
 
-bool NAMED_ILIST::delete_element(const char *name, uint length, void (*free_element)(const char *name, uchar*))
+bool NAMED_ILIST::delete_element(const char *name, size_t length, void (*free_element)(const char *name, uchar*))
 {
   I_List_iterator<NAMED_ILINK> it(*this);
   NAMED_ILINK *element;
@@ -112,11 +112,11 @@ KEY_CACHE *get_key_cache(const LEX_CSTRING *cache_name)
                                   cache_name->str, cache_name->length, 0));
 }
 
-KEY_CACHE *create_key_cache(const char *name, uint length)
+KEY_CACHE *create_key_cache(const char *name, size_t length)
 {
   KEY_CACHE *key_cache;
   DBUG_ENTER("create_key_cache");
-  DBUG_PRINT("enter",("name: %.*s", length, name));
+  DBUG_PRINT("enter",("name: %.*s", (int)length, name));
   
   if ((key_cache= (KEY_CACHE*) my_malloc(sizeof(KEY_CACHE),
                                              MYF(MY_ZEROFILL | MY_WME))))
@@ -144,7 +144,7 @@ KEY_CACHE *create_key_cache(const char *name, uint length)
 }
 
 
-KEY_CACHE *get_or_create_key_cache(const char *name, uint length)
+KEY_CACHE *get_or_create_key_cache(const char *name, size_t length)
 {
   LEX_CSTRING key_cache_name;
   KEY_CACHE *key_cache;
@@ -190,11 +190,11 @@ Rpl_filter *get_rpl_filter(LEX_CSTRING *filter_name)
                                    filter_name->str, filter_name->length, 0));
 }
 
-Rpl_filter *create_rpl_filter(const char *name, uint length)
+Rpl_filter *create_rpl_filter(const char *name, size_t length)
 {
   Rpl_filter *filter;
   DBUG_ENTER("create_rpl_filter");
-  DBUG_PRINT("enter",("name: %.*s", length, name));
+  DBUG_PRINT("enter",("name: %.*s", (int)length, name));
   
   filter= new Rpl_filter;
   if (filter) 
@@ -209,7 +209,7 @@ Rpl_filter *create_rpl_filter(const char *name, uint length)
 }
 
 
-Rpl_filter *get_or_create_rpl_filter(const char *name, uint length)
+Rpl_filter *get_or_create_rpl_filter(const char *name, size_t length)
 {
   LEX_CSTRING rpl_filter_name;
   Rpl_filter *filter;
diff --git a/sql/keycaches.h b/sql/keycaches.h
index 669d8d2355d..ff0380ba09a 100644
--- a/sql/keycaches.h
+++ b/sql/keycaches.h
@@ -31,7 +31,7 @@ class NAMED_ILIST: public I_List<NAMED_ILINK>
 {
   public:
   void delete_elements(void (*free_element)(const char*, uchar*));
-  bool delete_element(const char *name, uint length, void (*free_element)(const char*, uchar*));
+  bool delete_element(const char *name, size_t length, void (*free_element)(const char*, uchar*));
 };
 
 /* For key cache */
@@ -39,9 +39,9 @@ extern LEX_CSTRING default_key_cache_base;
 extern KEY_CACHE zero_key_cache;
 extern NAMED_ILIST key_caches;
 
-KEY_CACHE *create_key_cache(const char *name, uint length);
+KEY_CACHE *create_key_cache(const char *name, size_t length);
 KEY_CACHE *get_key_cache(const LEX_CSTRING *cache_name);
-KEY_CACHE *get_or_create_key_cache(const char *name, uint length);
+KEY_CACHE *get_or_create_key_cache(const char *name, size_t length);
 void free_key_cache(const char *name, KEY_CACHE *key_cache);
 bool process_key_caches(process_key_cache_t func, void *param);
 
@@ -49,9 +49,9 @@ bool process_key_caches(process_key_cache_t func, void *param);
 extern LEX_CSTRING default_rpl_filter_base;
 extern NAMED_ILIST rpl_filters;
 
-Rpl_filter *create_rpl_filter(const char *name, uint length);
+Rpl_filter *create_rpl_filter(const char *name, size_t length);
 Rpl_filter *get_rpl_filter(LEX_CSTRING *filter_name);
-Rpl_filter *get_or_create_rpl_filter(const char *name, uint length);
+Rpl_filter *get_or_create_rpl_filter(const char *name, size_t length);
 void free_rpl_filter(const char *name, Rpl_filter *filter);
 void free_all_rpl_filters(void);
 
diff --git a/sql/log.cc b/sql/log.cc
index dfbe2c33e2e..8ed53a60195 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -688,10 +688,9 @@ void Log_to_csv_event_handler::cleanup()
 */
 
 bool Log_to_csv_event_handler::
-  log_general(THD *thd, my_hrtime_t event_time, const char *user_host,
-              uint user_host_len, my_thread_id thread_id_arg,
-              const char *command_type, uint command_type_len,
-              const char *sql_text, uint sql_text_len,
+  log_general(THD *thd, my_hrtime_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id_arg,
+              const char *command_type, size_t command_type_len,
+              const char *sql_text, size_t sql_text_len,
               CHARSET_INFO *client_cs)
 {
   TABLE_LIST table_list;
@@ -852,9 +851,9 @@ err:
 
 bool Log_to_csv_event_handler::
   log_slow(THD *thd, my_hrtime_t current_time,
-           const char *user_host, uint user_host_len,
+           const char *user_host, size_t user_host_len,
            ulonglong query_utime, ulonglong lock_utime, bool is_command,
-           const char *sql_text, uint sql_text_len)
+           const char *sql_text, size_t sql_text_len)
 {
   TABLE_LIST table_list;
   TABLE *table;
@@ -1071,9 +1070,9 @@ void Log_to_file_event_handler::init_pthread_objects()
 
 bool Log_to_file_event_handler::
   log_slow(THD *thd, my_hrtime_t current_time,
-           const char *user_host, uint user_host_len,
+           const char *user_host, size_t user_host_len,
            ulonglong query_utime, ulonglong lock_utime, bool is_command,
-           const char *sql_text, uint sql_text_len)
+           const char *sql_text, size_t sql_text_len)
 {
   Silence_log_table_errors error_handler;
   thd->push_internal_handler(&error_handler);
@@ -1092,10 +1091,9 @@ bool Log_to_file_event_handler::
 */
 
 bool Log_to_file_event_handler::
-  log_general(THD *thd, my_hrtime_t event_time, const char *user_host,
-              uint user_host_len, my_thread_id thread_id_arg,
-              const char *command_type, uint command_type_len,
-              const char *sql_text, uint sql_text_len,
+  log_general(THD *thd, my_hrtime_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id_arg,
+              const char *command_type, size_t command_type_len,
+              const char *sql_text, size_t sql_text_len,
               CHARSET_INFO *client_cs)
 {
   Silence_log_table_errors error_handler;
@@ -1298,7 +1296,7 @@ bool LOGGER::flush_general_log()
     TRUE    error occurred
 */
 
-bool LOGGER::slow_log_print(THD *thd, const char *query, uint query_length,
+bool LOGGER::slow_log_print(THD *thd, const char *query, size_t query_length,
                             ulonglong current_utime)
 
 {
@@ -1347,7 +1345,7 @@ bool LOGGER::slow_log_print(THD *thd, const char *query, uint query_length,
     {
       is_command= TRUE;
       query= command_name[thd->get_command()].str;
-      query_length= command_name[thd->get_command()].length;
+      query_length= (uint)command_name[thd->get_command()].length;
     }
 
     for (current_handler= slow_log_handler_list; *current_handler ;)
@@ -1362,7 +1360,7 @@ bool LOGGER::slow_log_print(THD *thd, const char *query, uint query_length,
 }
 
 bool LOGGER::general_log_write(THD *thd, enum enum_server_command command,
-                               const char *query, uint query_length)
+                               const char *query, size_t query_length)
 {
   bool error= FALSE;
   Log_event_handler **current_handler= general_log_handler_list;
@@ -1379,8 +1377,8 @@ bool LOGGER::general_log_write(THD *thd, enum enum_server_command command,
   mysql_audit_general_log(thd, hrtime_to_time(current_time),
                           user_host_buff, user_host_len,
                           command_name[(uint) command].str,
-                          command_name[(uint) command].length,
-                          query, query_length);
+                          (uint)command_name[(uint) command].length,
+                          query, (uint)query_length);
                         
   if (opt_log && log_command(thd, command))
   {
@@ -1402,7 +1400,7 @@ bool LOGGER::general_log_write(THD *thd, enum enum_server_command command,
 bool LOGGER::general_log_print(THD *thd, enum enum_server_command command,
                                const char *format, va_list args)
 {
-  uint message_buff_len= 0;
+  size_t message_buff_len= 0;
   char message_buff[MAX_LOG_BUFFER_SIZE];
 
   /* prepare message */
@@ -2664,7 +2662,7 @@ bool MYSQL_LOG::open(
   if (log_type == LOG_NORMAL)
   {
     char *end;
-    int len=my_snprintf(buff, sizeof(buff), "%s, Version: %s (%s). "
+    size_t len=my_snprintf(buff, sizeof(buff), "%s, Version: %s (%s). "
 #ifdef EMBEDDED_LIBRARY
                         "embedded library\n",
                         my_progname, server_version, MYSQL_COMPILATION_COMMENT
@@ -2871,15 +2869,14 @@ void MYSQL_QUERY_LOG::reopen_file()
     TRUE - error occurred
 */
 
-bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host,
-                            uint user_host_len, my_thread_id thread_id_arg,
-                            const char *command_type, uint command_type_len,
-                            const char *sql_text, uint sql_text_len)
+bool MYSQL_QUERY_LOG::write(time_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id_arg,
+                            const char *command_type, size_t command_type_len,
+                            const char *sql_text, size_t sql_text_len)
 {
   char buff[32];
   char local_time_buff[MAX_TIME_SIZE];
   struct tm start;
-  uint time_buff_len= 0;
+  size_t time_buff_len= 0;
 
   mysql_mutex_lock(&LOCK_log);
 
@@ -2973,10 +2970,9 @@ err:
 */
 
 bool MYSQL_QUERY_LOG::write(THD *thd, time_t current_time,
-                            const char *user_host,
-                            uint user_host_len, ulonglong query_utime,
+                            const char *user_host, size_t user_host_len, ulonglong query_utime,
                             ulonglong lock_utime, bool is_command,
-                            const char *sql_text, uint sql_text_len)
+                            const char *sql_text, size_t sql_text_len)
 {
   bool error= 0;
   char llbuff[22];
@@ -3628,8 +3624,8 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
           Write the current binlog checkpoint into the log, so XA recovery will
           know from where to start recovery.
         */
-        uint off= dirname_length(log_file_name);
-        uint len= strlen(log_file_name) - off;
+        size_t off= dirname_length(log_file_name);
+        size_t len= strlen(log_file_name) - off;
         char *entry_mem, *name_mem;
         if (!(new_xid_list_entry = (xid_count_per_binlog *)
               my_multi_malloc(MYF(MY_WME),
@@ -3639,7 +3635,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
           goto err;
         memcpy(name_mem, log_file_name+off, len);
         new_xid_list_entry->binlog_name= name_mem;
-        new_xid_list_entry->binlog_name_len= len;
+        new_xid_list_entry->binlog_name_len= (int)len;
         new_xid_list_entry->xid_count= 0;
         new_xid_list_entry->notify_count= 0;
 
@@ -3659,7 +3655,7 @@ bool MYSQL_BIN_LOG::open(const char *log_name,
         if (!b)
           b= new_xid_list_entry;
         strmake(buf, b->binlog_name, b->binlog_name_len);
-        Binlog_checkpoint_log_event ev(buf, len);
+        Binlog_checkpoint_log_event ev(buf, (uint)len);
         DBUG_EXECUTE_IF("crash_before_write_checkpoint_event",
                         flush_io_cache(&log_file);
                         mysql_file_sync(log_file.file, MYF(MY_WME));
@@ -3951,7 +3947,7 @@ int MYSQL_BIN_LOG::find_log_pos(LOG_INFO *linfo, const char *log_name,
 
   for (;;)
   {
-    uint length;
+    size_t length;
     my_off_t offset= my_b_tell(&index_file);
 
     DBUG_EXECUTE_IF("simulate_find_log_pos_error",
@@ -4021,7 +4017,7 @@ end:
 int MYSQL_BIN_LOG::find_next_log(LOG_INFO* linfo, bool need_lock)
 {
   int error= 0;
-  uint length;
+  size_t length;
   char fname[FN_REFLEN];
   char *full_fname= linfo->log_file_name;
 
@@ -4711,7 +4707,7 @@ int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *reclaimed_space,
 
   for (;;)
   {
-    uint length;
+    size_t length;
 
     if ((length=my_b_gets(&purge_index_file, log_info.log_file_name,
                           FN_REFLEN)) <= 1)
@@ -5058,7 +5054,7 @@ MYSQL_BIN_LOG::is_gtid_cached(THD *thd)
 
 void MYSQL_BIN_LOG::make_log_name(char* buf, const char* log_ident)
 {
-  uint dir_len = dirname_length(log_file_name); 
+  size_t dir_len = dirname_length(log_file_name); 
   if (dir_len >= FN_REFLEN)
     dir_len=FN_REFLEN-1;
   strnmov(buf, log_file_name, dir_len);
@@ -6576,7 +6572,7 @@ bool general_log_print(THD *thd, enum enum_server_command command,
 }
 
 bool general_log_write(THD *thd, enum enum_server_command command,
-                       const char *query, uint query_length)
+                       const char *query, size_t query_length)
 {
   /* Write the message to the log if we want to log this king of commands */
   if (logger.log_command(thd, command) || mysql_audit_general_enabled())
@@ -6923,7 +6919,7 @@ uint MYSQL_BIN_LOG::next_file_id()
 class CacheWriter: public Log_event_writer
 {
 public:
-  ulong remains;
+  size_t remains;
 
   CacheWriter(THD *thd_arg, IO_CACHE *file_arg, bool do_checksum,
               Binlog_crypt_data *cr)
@@ -6976,9 +6972,9 @@ int MYSQL_BIN_LOG::write_cache(THD *thd, IO_CACHE *cache)
   mysql_mutex_assert_owner(&LOCK_log);
   if (reinit_io_cache(cache, READ_CACHE, 0, 0, 0))
     DBUG_RETURN(ER_ERROR_ON_WRITE);
-  uint length= my_b_bytes_in_cache(cache), group, carry, hdr_offs;
-  long val;
-  ulong end_log_pos_inc= 0; // each event processed adds BINLOG_CHECKSUM_LEN 2 t
+  size_t length= my_b_bytes_in_cache(cache), group, carry, hdr_offs;
+  size_t val;
+  size_t end_log_pos_inc= 0; // each event processed adds BINLOG_CHECKSUM_LEN 2 t
   uchar header[LOG_EVENT_HEADER_LEN];
   CacheWriter writer(thd, &log_file, binlog_checksum_options, &crypto);
 
@@ -7003,7 +6999,7 @@ int MYSQL_BIN_LOG::write_cache(THD *thd, IO_CACHE *cache)
     split.
   */
 
-  group= (uint)my_b_tell(&log_file);
+  group= (size_t)my_b_tell(&log_file);
   hdr_offs= carry= 0;
 
   do
@@ -7015,12 +7011,12 @@ int MYSQL_BIN_LOG::write_cache(THD *thd, IO_CACHE *cache)
     if (unlikely(carry > 0))
     {
       DBUG_ASSERT(carry < LOG_EVENT_HEADER_LEN);
-      uint tail= LOG_EVENT_HEADER_LEN - carry;
+      size_t tail= LOG_EVENT_HEADER_LEN - carry;
 
       /* assemble both halves */
       memcpy(&header[carry], (char *)cache->read_pos, tail);
 
-      ulong len= uint4korr(header + EVENT_LEN_OFFSET);
+      uint32 len= uint4korr(header + EVENT_LEN_OFFSET);
       writer.remains= len;
 
       /* fix end_log_pos */
@@ -8669,7 +8665,7 @@ static void print_buffer_to_file(enum loglevel level, const char *buffer,
   struct tm tm_tmp;
   struct tm *start;
   THD *thd= 0;
-  int tag_length= 0;
+  size_t tag_length= 0;
   char tag[NAME_LEN];
   DBUG_ENTER("print_buffer_to_file");
   DBUG_PRINT("enter",("buffer: %s", buffer));
@@ -8705,7 +8701,7 @@ static void print_buffer_to_file(enum loglevel level, const char *buffer,
           (unsigned long) (thd ? thd->thread_id : 0),
           (level == ERROR_LEVEL ? "ERROR" : level == WARNING_LEVEL ?
            "Warning" : "Note"),
-          tag_length, tag,
+          (int) tag_length, tag,
           (int) length, buffer);
 
   fflush(stderr);
@@ -10044,7 +10040,7 @@ int TC_LOG_BINLOG::recover(LOG_INFO *linfo, const char *last_log_name,
       case BINLOG_CHECKPOINT_EVENT:
         if (first_round && do_xa)
         {
-          uint dir_len;
+          size_t dir_len;
           Binlog_checkpoint_log_event *cev= (Binlog_checkpoint_log_event *)ev;
           if (cev->binlog_file_len >= FN_REFLEN)
             sql_print_warning("Incorrect binlog checkpoint event with too "
@@ -10441,7 +10437,7 @@ static struct st_mysql_sys_var *binlog_sys_vars[]=
 static void
 set_binlog_snapshot_file(const char *src)
 {
-  int dir_len = dirname_length(src);
+  size_t dir_len = dirname_length(src);
   strmake_buf(binlog_snapshot_file, src + dir_len);
 }
 
diff --git a/sql/log.h b/sql/log.h
index 6305dd97355..098824d9ec8 100644
--- a/sql/log.h
+++ b/sql/log.h
@@ -359,14 +359,13 @@ class MYSQL_QUERY_LOG: public MYSQL_LOG
 public:
   MYSQL_QUERY_LOG() : last_time(0) {}
   void reopen_file();
-  bool write(time_t event_time, const char *user_host,
-             uint user_host_len, my_thread_id thread_id,
-             const char *command_type, uint command_type_len,
-             const char *sql_text, uint sql_text_len);
+  bool write(time_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id,
+             const char *command_type, size_t command_type_len,
+             const char *sql_text, size_t sql_text_len);
   bool write(THD *thd, time_t current_time,
-             const char *user_host, uint user_host_len,
+             const char *user_host, size_t user_host_len,
              ulonglong query_utime, ulonglong lock_utime, bool is_command,
-             const char *sql_text, uint sql_text_len);
+             const char *sql_text, size_t sql_text_len);
   bool open_slow_log(const char *log_name)
   {
     char buf[FN_REFLEN];
@@ -950,16 +949,14 @@ public:
   virtual void cleanup()= 0;
 
   virtual bool log_slow(THD *thd, my_hrtime_t current_time,
-                        const char *user_host,
-                        uint user_host_len, ulonglong query_utime,
+                        const char *user_host, size_t user_host_len, ulonglong query_utime,
                         ulonglong lock_utime, bool is_command,
-                        const char *sql_text, uint sql_text_len)= 0;
+                        const char *sql_text, size_t sql_text_len)= 0;
   virtual bool log_error(enum loglevel level, const char *format,
                          va_list args)= 0;
-  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host,
-                           uint user_host_len, my_thread_id thread_id,
-                           const char *command_type, uint command_type_len,
-                           const char *sql_text, uint sql_text_len,
+  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id,
+                           const char *command_type, size_t command_type_len,
+                           const char *sql_text, size_t sql_text_len,
                            CHARSET_INFO *client_cs)= 0;
   virtual ~Log_event_handler() {}
 };
@@ -979,16 +976,14 @@ public:
   virtual void cleanup();
 
   virtual bool log_slow(THD *thd, my_hrtime_t current_time,
-                        const char *user_host,
-                        uint user_host_len, ulonglong query_utime,
+                        const char *user_host, size_t user_host_len, ulonglong query_utime,
                         ulonglong lock_utime, bool is_command,
-                        const char *sql_text, uint sql_text_len);
+                        const char *sql_text, size_t sql_text_len);
   virtual bool log_error(enum loglevel level, const char *format,
                          va_list args);
-  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host,
-                           uint user_host_len, my_thread_id thread_id,
-                           const char *command_type, uint command_type_len,
-                           const char *sql_text, uint sql_text_len,
+  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id,
+                           const char *command_type, size_t command_type_len,
+                           const char *sql_text, size_t sql_text_len,
                            CHARSET_INFO *client_cs);
 
   int activate_log(THD *thd, uint log_type);
@@ -1011,16 +1006,14 @@ public:
   virtual void cleanup();
 
   virtual bool log_slow(THD *thd, my_hrtime_t current_time,
-                        const char *user_host,
-                        uint user_host_len, ulonglong query_utime,
+                        const char *user_host, size_t user_host_len, ulonglong query_utime,
                         ulonglong lock_utime, bool is_command,
-                        const char *sql_text, uint sql_text_len);
+                        const char *sql_text, size_t sql_text_len);
   virtual bool log_error(enum loglevel level, const char *format,
                          va_list args);
-  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host,
-                           uint user_host_len, my_thread_id thread_id,
-                           const char *command_type, uint command_type_len,
-                           const char *sql_text, uint sql_text_len,
+  virtual bool log_general(THD *thd, my_hrtime_t event_time, const char *user_host, size_t user_host_len, my_thread_id thread_id,
+                           const char *command_type, size_t command_type_len,
+                           const char *sql_text, size_t sql_text_len,
                            CHARSET_INFO *client_cs);
   void flush();
   void init_pthread_objects();
@@ -1074,12 +1067,12 @@ public:
   void cleanup_end();
   bool error_log_print(enum loglevel level, const char *format,
                       va_list args);
-  bool slow_log_print(THD *thd, const char *query, uint query_length,
+  bool slow_log_print(THD *thd, const char *query, size_t query_length,
                       ulonglong current_utime);
   bool general_log_print(THD *thd,enum enum_server_command command,
                          const char *format, va_list args);
   bool general_log_write(THD *thd, enum enum_server_command command,
-                         const char *query, uint query_length);
+                         const char *query, size_t query_length);
 
   /* we use this function to setup all enabled log event handlers */
   int set_handlers(ulonglong error_log_printer,
@@ -1131,7 +1124,7 @@ bool general_log_print(THD *thd, enum enum_server_command command,
                        const char *format,...);
 
 bool general_log_write(THD *thd, enum enum_server_command command,
-                       const char *query, uint query_length);
+                       const char *query, size_t query_length);
 
 void binlog_report_wait_for(THD *thd, THD *other_thd);
 void sql_perror(const char *message);
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 4005390b3de..cb4336afd77 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -221,7 +221,7 @@ static void inline slave_rows_error_report(enum loglevel level, int ha_error,
   const char *handler_error= (ha_error ? HA_ERR(ha_error) : NULL);
   char buff[MAX_SLAVE_ERRMSG], *slider;
   const char *buff_end= buff + sizeof(buff);
-  uint len;
+  size_t len;
   Diagnostics_area::Sql_condition_iterator it=
     thd->get_stmt_da()->sql_conditions();
   Relay_log_info const *rli= rgi->rli;
@@ -715,7 +715,7 @@ static inline int read_str(const char **buf, const char *buf_end,
   Transforms a string into "" or its expression in X'HHHH' form.
 */
 
-char *str_to_hex(char *to, const char *from, uint len)
+char *str_to_hex(char *to, const char *from, size_t len)
 {
   if (len)
   {
@@ -1605,13 +1605,13 @@ int Log_event_writer::encrypt_and_write(const uchar *pos, size_t len)
 
   if (ctx)
   {
-    dstsize= encryption_encrypted_length(len, ENCRYPTION_KEY_SYSTEM_DATA,
+    dstsize= encryption_encrypted_length((uint)len, ENCRYPTION_KEY_SYSTEM_DATA,
                                          crypto->key_version);
     if (!(dst= (uchar*)my_safe_alloca(dstsize)))
       return 1;
 
     uint dstlen;
-    if (encryption_ctx_update(ctx, pos, len, dst, &dstlen))
+    if (encryption_ctx_update(ctx, pos, (uint)len, dst, &dstlen))
       goto err;
     if (maybe_write_event_len(dst, dstlen))
       return 1;
@@ -1699,12 +1699,12 @@ int Log_event_writer::write_footer()
   Log_event::write_header()
 */
 
-bool Log_event::write_header(ulong event_data_length)
+bool Log_event::write_header(size_t event_data_length)
 {
   uchar header[LOG_EVENT_HEADER_LEN];
   ulong now;
   DBUG_ENTER("Log_event::write_header");
-  DBUG_PRINT("enter", ("filepos: %lld  length: %lu type: %d",
+  DBUG_PRINT("enter", ("filepos: %lld  length: %zu type: %d",
                        (longlong) writer->pos(), event_data_length,
                        (int) get_type_code()));
 
@@ -3074,7 +3074,7 @@ Rows_log_event::print_verbose_one_row(IO_CACHE *file, table_def *td,
     if (my_b_printf(file, "%s", prefix))
       goto err;
 
-  for (size_t i= 0; i < td->size(); i ++)
+  for (uint i= 0; i < (uint)td->size(); i ++)
   {
     size_t size;
     int is_null= (null_bits[null_bit_index / 8] 
@@ -3435,7 +3435,7 @@ Rows_log_event::calc_row_event_length(table_def *td,
 
   value+= (bitmap_bits_set(cols_bitmap) + 7) / 8;
 
-  for (size_t i= 0; i < td->size(); i ++)
+  for (uint i= 0; i < (uint)td->size(); i ++)
   {
     int is_null;
     is_null= (null_bits[null_bit_index / 8] >> (null_bit_index % 8)) & 0x01;
@@ -4262,8 +4262,7 @@ Query_log_event::Query_log_event()
   Creates an event for binlogging
   The value for `errcode' should be supplied by caller.
 */
-Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg,
-				 ulong query_length, bool using_trans,
+Query_log_event::Query_log_event(THD* thd_arg, const char* query_arg, size_t query_length, bool using_trans,
 				 bool direct, bool suppress_use, int errcode)
 
   :Log_event(thd_arg,
@@ -4489,7 +4488,7 @@ get_str_len_and_pointer(const Log_event::Byte **src,
 
 static void copy_str_and_move(const char **src, 
                               Log_event::Byte **dst, 
-                              uint len)
+                              size_t len)
 {
   memcpy(*dst, *src, len);
   *src= (const char *)*dst;
@@ -4622,7 +4621,7 @@ Query_log_event::Query_log_event(const char* buf, uint event_len,
       event from the relay log.
     */
     DBUG_ASSERT(description_event->binlog_version < 4);
-    master_data_written= data_written;
+    master_data_written= (uint32)data_written;
   }
   /*
     We have parsed everything we know in the post header for QUERY_EVENT,
@@ -4938,7 +4937,7 @@ Query_log_event::dummy_event(String *packet, ulong ev_offset,
       possibly just @`!`).
     */
     static const char var_name[]= "!dummyvar";
-    uint name_len= data_len - (min_user_var_event_len - 1);
+    size_t name_len= data_len - (min_user_var_event_len - 1);
 
     p[EVENT_TYPE_OFFSET]= USER_VAR_EVENT;
     int4store(p + LOG_EVENT_HEADER_LEN, name_len);
@@ -8394,7 +8393,7 @@ err:
   fully contruct the event object.
 */
 bool
-Gtid_list_log_event::peek(const char *event_start, uint32 event_len,
+Gtid_list_log_event::peek(const char *event_start, size_t event_len,
                           enum enum_binlog_checksum_alg checksum_alg,
                           rpl_gtid **out_gtid_list, uint32 *out_list_len,
                           const Format_description_log_event *fdev)
@@ -9125,7 +9124,7 @@ bool User_var_log_event::write()
   uchar buf2[MY_MAX(8, DECIMAL_MAX_FIELD_SIZE + 2)], *pos= buf2;
   uint unsigned_len= 0;
   uint buf1_length;
-  ulong event_length;
+  size_t event_length;
 
   int4store(buf, name_len);
   
@@ -9368,7 +9367,7 @@ int User_var_log_event::do_apply_event(rpl_group_info *rgi)
       break;
     }
     case STRING_RESULT:
-      it= new (thd->mem_root) Item_string(thd, val, val_len, charset);
+      it= new (thd->mem_root) Item_string(thd, val, (uint)val_len, charset);
       break;
     case ROW_RESULT:
     default:
@@ -10411,7 +10410,7 @@ bool Execute_load_query_log_event::print(FILE* file,
   {
     if (my_b_write(&cache, (uchar*) query, fn_pos_start) ||
         my_b_write_string(&cache, " LOCAL INFILE ") ||
-        pretty_print_str(&cache, local_fname, strlen(local_fname)))
+        pretty_print_str(&cache, local_fname, (int)strlen(local_fname)))
       goto err;
 
     if (dup_handling == LOAD_DUP_REPLACE)
@@ -12284,7 +12283,7 @@ int Table_map_log_event::rewrite_db(const char* new_db, size_t new_len,
                        LOG_EVENT_MINIMAL_HEADER_LEN) + TABLE_MAP_HEADER_LEN;
   int len_diff;
 
-  if (!(len_diff= new_len - m_dblen))
+  if (!(len_diff= (int)(new_len - m_dblen)))
   {
     memcpy((void*) (temp_buf + header_len + 1), new_db, m_dblen + 1);
     memcpy((void*) m_dbnam, new_db, m_dblen + 1);
@@ -12306,7 +12305,7 @@ int Table_map_log_event::rewrite_db(const char* new_db, size_t new_len,
 
   // Rewrite temp_buf
   char* ptr= new_temp_buf;
-  ulong cnt= 0;
+  size_t cnt= 0;
 
   // Copy header and change event length
   memcpy(ptr, temp_buf, header_len);
diff --git a/sql/log_event.h b/sql/log_event.h
index 5de72c55040..97e06c165b9 100644
--- a/sql/log_event.h
+++ b/sql/log_event.h
@@ -1203,7 +1203,7 @@ public:
   /* The number of seconds the query took to run on the master. */
   ulong exec_time;
   /* Number of bytes written by write() function */
-  ulong data_written;
+  size_t data_written;
 
   /*
     The master's server id (is preserved in the relay log; used to
@@ -1364,10 +1364,10 @@ public:
   static void operator delete(void*, void*) { }
 
 #ifdef MYSQL_SERVER
-  bool write_header(ulong data_length);
-  bool write_data(const uchar *buf, ulong data_length)
+  bool write_header(size_t event_data_length);
+  bool write_data(const uchar *buf, size_t data_length)
   { return writer->write_data(buf, data_length); }
-  bool write_data(const char *buf, ulong data_length)
+  bool write_data(const char *buf, size_t data_length)
   { return write_data((uchar*)buf, data_length); }
   bool write_footer()
   { return writer->write_footer(); }
@@ -2114,7 +2114,7 @@ public:
 
 #ifdef MYSQL_SERVER
 
-  Query_log_event(THD* thd_arg, const char* query_arg, ulong query_length,
+  Query_log_event(THD* thd_arg, const char* query_arg, size_t query_length,
                   bool using_trans, bool direct, bool suppress_use, int error);
   const char* get_db() { return db; }
 #ifdef HAVE_REPLICATION
@@ -2498,10 +2498,10 @@ public:
   bool is_concurrent;
 
   /* fname doesn't point to memory inside Log_event::temp_buf  */
-  void set_fname_outside_temp_buf(const char *afname, uint alen)
+  void set_fname_outside_temp_buf(const char *afname, size_t alen)
   {
     fname= afname;
-    fname_len= alen;
+    fname_len= (uint)alen;
     local_fname= TRUE;
   }
   /* fname doesn't point to memory inside Log_event::temp_buf  */
@@ -3050,9 +3050,9 @@ public:
     UNSIGNED_F= 1
   };
   const char *name;
-  uint name_len;
+  size_t name_len;
   const char *val;
-  ulong val_len;
+  size_t val_len;
   Item_result type;
   uint charset_number;
   bool is_null;
@@ -3060,8 +3060,8 @@ public:
 #ifdef MYSQL_SERVER
   bool deferred;
   query_id_t query_id;
-  User_var_log_event(THD* thd_arg, const char *name_arg, uint name_len_arg,
-                     const char *val_arg, ulong val_len_arg, Item_result type_arg,
+  User_var_log_event(THD* thd_arg, const char *name_arg, size_t name_len_arg,
+                     const char *val_arg, size_t val_len_arg, Item_result type_arg,
 		     uint charset_number_arg, uchar flags_arg,
                      bool using_trans, bool direct)
     :Log_event(thd_arg, 0, using_trans),
@@ -3519,7 +3519,7 @@ public:
   virtual int do_apply_event(rpl_group_info *rgi);
   enum_skip_reason do_shall_skip(rpl_group_info *rgi);
 #endif
-  static bool peek(const char *event_start, uint32 event_len,
+  static bool peek(const char *event_start, size_t event_len,
                    enum enum_binlog_checksum_alg checksum_alg,
                    rpl_gtid **out_gtid_list, uint32 *out_list_len,
                    const Format_description_log_event *fdev);
@@ -3864,7 +3864,7 @@ public:
   bool is_valid() const { return 1; }
 };
 #endif
-char *str_to_hex(char *to, const char *from, uint len);
+char *str_to_hex(char *to, const char *from, size_t len);
 
 /**
   @class Annotate_rows_log_event
diff --git a/sql/mf_iocache_encr.cc b/sql/mf_iocache_encr.cc
index 546e0fe03a0..8d7cea4b050 100644
--- a/sql/mf_iocache_encr.cc
+++ b/sql/mf_iocache_encr.cc
@@ -176,9 +176,9 @@ static int my_b_encr_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
     crypt_data->inbuf_counter= crypt_data->counter;
     set_iv(iv, info->pos_in_file, crypt_data->inbuf_counter);
 
-    if (encryption_crypt(Buffer, length, ebuffer, &elength,
-                         crypt_data->key, sizeof(crypt_data->key),
-                         iv, sizeof(iv), ENCRYPTION_FLAG_ENCRYPT,
+    if (encryption_crypt(Buffer, (uint)length, ebuffer, &elength,
+                         crypt_data->key, (uint) sizeof(crypt_data->key),
+                         iv, (uint) sizeof(iv), ENCRYPTION_FLAG_ENCRYPT,
                          keyid, keyver))
     {
       my_errno= 1;
@@ -193,7 +193,7 @@ static int my_b_encr_write(IO_CACHE *info, const uchar *Buffer, size_t Count)
         buffer_length bytes should *always* produce block_length bytes
       */
       DBUG_ASSERT(crypt_data->block_length == 0 || crypt_data->block_length == wlength);
-      DBUG_ASSERT(elength <= encryption_encrypted_length(length, keyid, keyver));
+      DBUG_ASSERT(elength <= encryption_encrypted_length((uint)length, keyid, keyver));
       crypt_data->block_length= wlength;
     }
     else
diff --git a/sql/multi_range_read.cc b/sql/multi_range_read.cc
index c532a489684..ec3c85b34c4 100644
--- a/sql/multi_range_read.cc
+++ b/sql/multi_range_read.cc
@@ -1656,10 +1656,10 @@ int DsMrr_impl::dsmrr_explain_info(uint mrr_mode, char *str, size_t size)
     else if (mrr_mode & DSMRR_IMPL_SORT_ROWIDS)
       used_str= rowid_ordered;
 
-    uint used_str_len= strlen(used_str);
-    uint copy_len= MY_MIN(used_str_len, size);
+    size_t used_str_len= strlen(used_str);
+    size_t copy_len= MY_MIN(used_str_len, size);
     memcpy(str, used_str, copy_len);
-    return copy_len;
+    return (int)copy_len;
   }
   return 0;
 }
@@ -1718,7 +1718,7 @@ bool DsMrr_impl::get_disk_sweep_mrr_cost(uint keynr, ha_rows rows, uint flags,
   else
   {
     cost->reset();
-    *buffer_size= MY_MAX(*buffer_size, 
+    *buffer_size= (uint)MY_MAX(*buffer_size, 
                       (size_t)(1.2*rows_in_last_step) * elem_size + 
                       primary_file->ref_length + table->key_info[keynr].key_length);
   }
diff --git a/sql/my_decimal.cc b/sql/my_decimal.cc
index 6d1c746fca8..338f78d8f08 100644
--- a/sql/my_decimal.cc
+++ b/sql/my_decimal.cc
@@ -238,7 +238,7 @@ int my_decimal2binary(uint mask, const my_decimal *d, uchar *bin, int prec,
     E_DEC_OOM
 */
 
-int str2my_decimal(uint mask, const char *from, uint length,
+int str2my_decimal(uint mask, const char *from, size_t length,
                    CHARSET_INFO *charset, my_decimal *decimal_value,
                    const char **end_ptr)
 {
diff --git a/sql/my_decimal.h b/sql/my_decimal.h
index 918213568fc..775617dce0f 100644
--- a/sql/my_decimal.h
+++ b/sql/my_decimal.h
@@ -365,11 +365,11 @@ int str2my_decimal(uint mask, const char *str, my_decimal *d, char **end)
 }
 
 
-int str2my_decimal(uint mask, const char *from, uint length,
+int str2my_decimal(uint mask, const char *from, size_t length,
                    CHARSET_INFO *charset, my_decimal *decimal_value,
                    const char **end);
 
-inline int str2my_decimal(uint mask, const char *from, uint length,
+inline int str2my_decimal(uint mask, const char *from, size_t length,
                           CHARSET_INFO *charset, my_decimal *decimal_value)
 {
   const char *end;
diff --git a/sql/my_json_writer.cc b/sql/my_json_writer.cc
index 1d61986034a..d219e88b98b 100644
--- a/sql/my_json_writer.cc
+++ b/sql/my_json_writer.cc
@@ -221,7 +221,7 @@ bool Single_line_formatting_helper::on_add_member(const char *name)
       buf_ptr+=len;
       *(buf_ptr++)= 0;
 
-      line_len= owner->indent_level + len + 1;
+      line_len= owner->indent_level + (uint)len + 1;
       state= ADD_MEMBER;
       return true; // handled
     }
@@ -286,7 +286,7 @@ bool Single_line_formatting_helper::on_add_str(const char *str)
     memcpy(buf_ptr, str, len);
     buf_ptr+=len;
     *(buf_ptr++)= 0;
-    line_len += len + 4;
+    line_len += (uint)len + 4;
     return true; // handled
   }
 
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 073788370f1..15353e4729a 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -626,7 +626,7 @@ char mysql_real_data_home[FN_REFLEN],
      *opt_init_file, *opt_tc_log_file;
 char *lc_messages_dir_ptr= lc_messages_dir, *log_error_file_ptr;
 char mysql_unpacked_real_data_home[FN_REFLEN];
-int mysql_unpacked_real_data_home_len;
+size_t mysql_unpacked_real_data_home_len;
 uint mysql_real_data_home_len, mysql_data_home_len= 1;
 uint reg_ext_length;
 const key_map key_map_empty(0);
@@ -5681,8 +5681,8 @@ static void test_lc_time_sz()
   DBUG_ENTER("test_lc_time_sz");
   for (MY_LOCALE **loc= my_locales; *loc; loc++)
   {
-    uint max_month_len= 0;
-    uint max_day_len = 0;
+    size_t max_month_len= 0;
+    size_t max_day_len= 0;
     for (const char **month= (*loc)->month_names->type_names; *month; month++)
     {
       set_if_bigger(max_month_len,
@@ -8526,7 +8526,7 @@ SHOW_VAR status_vars[]= {
   {"Handler_commit",           (char*) offsetof(STATUS_VAR, ha_commit_count), SHOW_LONG_STATUS},
   {"Handler_delete",           (char*) offsetof(STATUS_VAR, ha_delete_count), SHOW_LONG_STATUS},
   {"Handler_discover",         (char*) offsetof(STATUS_VAR, ha_discover_count), SHOW_LONG_STATUS},
-  {"Handler_external_lock",    (char*) offsetof(STATUS_VAR, ha_external_lock_count), SHOW_LONGLONG_STATUS},
+  {"Handler_external_lock",    (char*) offsetof(STATUS_VAR, ha_external_lock_count), SHOW_LONG_STATUS},
   {"Handler_icp_attempts",     (char*) offsetof(STATUS_VAR, ha_icp_attempts), SHOW_LONG_STATUS},
   {"Handler_icp_match",        (char*) offsetof(STATUS_VAR, ha_icp_match), SHOW_LONG_STATUS},
   {"Handler_mrr_init",         (char*) offsetof(STATUS_VAR, ha_mrr_init_count),  SHOW_LONG_STATUS},
@@ -10000,7 +10000,7 @@ static int fix_paths(void)
 
   my_realpath(mysql_unpacked_real_data_home, mysql_real_data_home, MYF(0));
   mysql_unpacked_real_data_home_len= 
-    (int) strlen(mysql_unpacked_real_data_home);
+  strlen(mysql_unpacked_real_data_home);
   if (mysql_unpacked_real_data_home[mysql_unpacked_real_data_home_len-1] == FN_LIBCHAR)
     --mysql_unpacked_real_data_home_len;
 
diff --git a/sql/mysqld.h b/sql/mysqld.h
index 3387ae7c458..bb22753bbf1 100644
--- a/sql/mysqld.h
+++ b/sql/mysqld.h
@@ -265,7 +265,7 @@ extern "C" MYSQL_PLUGIN_IMPORT ulong server_id;
 extern ulong concurrency;
 extern time_t server_start_time, flush_status_time;
 extern char *opt_mysql_tmpdir, mysql_charsets_dir[];
-extern int mysql_unpacked_real_data_home_len;
+extern size_t mysql_unpacked_real_data_home_len;
 extern MYSQL_PLUGIN_IMPORT MY_TMPDIR mysql_tmpdir_list;
 extern const char *first_keyword, *delayed_user, *binary_keyword;
 extern MYSQL_PLUGIN_IMPORT const char  *my_localhost;
diff --git a/sql/net_serv.cc b/sql/net_serv.cc
index fd0139c1e03..cab9b0ede69 100644
--- a/sql/net_serv.cc
+++ b/sql/net_serv.cc
@@ -104,7 +104,7 @@ extern uint test_flags;
 extern ulong bytes_sent, bytes_received, net_big_packet_count;
 #ifdef HAVE_QUERY_CACHE
 #define USE_QUERY_CACHE
-extern void query_cache_insert(void *thd, const char *packet, ulong length,
+extern void query_cache_insert(void *thd, const char *packet, size_t length,
                                unsigned pkt_nr);
 #endif // HAVE_QUERY_CACHE
 #define update_statistics(A) A
@@ -117,7 +117,7 @@ extern my_bool thd_net_is_killed();
 #endif
 
 
-static my_bool net_write_buff(NET *, const uchar *, ulong);
+static my_bool net_write_buff(NET *, const uchar *, size_t len);
 
 my_bool net_allocate_new_packet(NET *net, void *thd, uint my_flags);
 
@@ -542,13 +542,13 @@ net_write_command(NET *net,uchar command,
 */
 
 static my_bool
-net_write_buff(NET *net, const uchar *packet, ulong len)
+net_write_buff(NET *net, const uchar *packet, size_t len)
 {
-  ulong left_length;
+  size_t left_length;
   if (net->compress && net->max_packet > MAX_PACKET_LENGTH)
-    left_length= (ulong) (MAX_PACKET_LENGTH - (net->write_pos - net->buff));
+    left_length= (MAX_PACKET_LENGTH - (net->write_pos - net->buff));
   else
-    left_length= (ulong) (net->buff_end - net->write_pos);
+    left_length= (net->buff_end - net->write_pos);
 
 #ifdef DEBUG_DATA_PACKETS
   DBUG_DUMP("data_written", packet, len);
@@ -1034,7 +1034,7 @@ retry:
 #endif
       if (i == 0)
       {					/* First parts is packet length */
-	ulong helping;
+        size_t helping;
 #ifndef DEBUG_DATA_PACKETS
         DBUG_DUMP("packet_header", net->buff+net->where_b,
                   NET_HEADER_SIZE);
@@ -1238,7 +1238,7 @@ my_net_read_packet_reallen(NET *net, my_bool read_from_server, ulong* reallen)
       size_t total_length= 0;
       do
       {
-	net->where_b += len;
+	net->where_b += (ulong)len;
 	total_length += len;
 	len = my_real_read(net,&complen, 0);
       } while (len == MAX_PACKET_LENGTH);
@@ -1251,10 +1251,10 @@ my_net_read_packet_reallen(NET *net, my_bool read_from_server, ulong* reallen)
     if (len != packet_error)
     {
       net->read_pos[len]=0;		/* Safeguard for mysql_use_result */
-      *reallen = len;
+      *reallen = (ulong)len;
     }
     MYSQL_NET_READ_DONE(0, len);
-    return len;
+    return (ulong)len;
 #ifdef HAVE_COMPRESS
   }
   else
@@ -1352,7 +1352,7 @@ my_net_read_packet_reallen(NET *net, my_bool read_from_server, ulong* reallen)
         MYSQL_NET_READ_DONE(1, 0);
 	return packet_error;
       }
-      buf_length+= complen;
+      buf_length+= (ulong)complen;
       *reallen += packet_len;
     }
 
@@ -1366,7 +1366,7 @@ my_net_read_packet_reallen(NET *net, my_bool read_from_server, ulong* reallen)
   }
 #endif /* HAVE_COMPRESS */
   MYSQL_NET_READ_DONE(0, len);
-  return len;
+  return (ulong)len;
 }
 
 
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 636e9bd496a..e783ee9bff4 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -6214,7 +6214,7 @@ static double ror_scan_selectivity(const ROR_INTERSECT_INFO *info,
                              &key_ptr, 0);
         keypart_map= (keypart_map << 1) | 1;
       }
-      min_range.length= max_range.length= (size_t) (key_ptr - key_val);
+      min_range.length= max_range.length= (uint) (key_ptr - key_val);
       min_range.keypart_map= max_range.keypart_map= keypart_map;
       records= (info->param->table->file->
                 records_in_range(scan->keynr, &min_range, &max_range));
@@ -7966,7 +7966,7 @@ Item_func_like::get_mm_leaf(RANGE_OPT_PARAM *param,
   }
 
   uint maybe_null= (uint) field->real_maybe_null();
-  uint field_length= field->pack_length() + maybe_null;
+  size_t field_length= field->pack_length() + maybe_null;
   size_t offset= maybe_null;
   size_t length= key_part->store_length;
 
diff --git a/sql/opt_split.cc b/sql/opt_split.cc
index 8fb8b787299..0cb76f03917 100644
--- a/sql/opt_split.cc
+++ b/sql/opt_split.cc
@@ -427,7 +427,7 @@ bool JOIN::check_for_splittable_materialized()
   }
 
   /* Count the candidate fields that can be accessed by ref */
-  uint spl_field_cnt= candidates.elements();
+  uint spl_field_cnt= (uint)candidates.elements();
   for (cand= cand_start; cand < cand_end; cand++)
   {
     if (!cand->is_usable_for_ref_access)
@@ -694,7 +694,7 @@ void JOIN::add_keyuses_for_splitting()
     (void) add_ext_keyuses_for_splitting_field(ext_keyuses_for_splitting,
                                                added_key_field);
   }
-  added_keyuse_count= ext_keyuses_for_splitting->elements();
+  added_keyuse_count= (uint)ext_keyuses_for_splitting->elements();
   if (!added_keyuse_count)
     goto err;
   sort_ext_keyuses(ext_keyuses_for_splitting);
diff --git a/sql/parse_file.cc b/sql/parse_file.cc
index aedb7a4f0af..90d766f15d2 100644
--- a/sql/parse_file.cc
+++ b/sql/parse_file.cc
@@ -760,12 +760,12 @@ File_parser::parse(uchar* base, MEM_ROOT *mem_root,
     {
       File_option *parameter= parameters+first_param,
 	*parameters_end= parameters+required;
-      int len= 0;
+      size_t len= 0;
       for (; parameter < parameters_end; parameter++)
       {
 	len= parameter->name.length;
 	// check length
-	if (len < (end-ptr) && ptr[len] != '=')
+	if (len < (size_t)(end-ptr) && ptr[len] != '=')
 	  continue;
 	// check keyword
 	if (memcmp(parameter->name.str, ptr, len) == 0)
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 636e0db437a..5939da09eae 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -145,8 +145,7 @@ partition_info *partition_info::get_clone(THD *thd)
     @retval false Partition not found
 */
 
-bool partition_info::add_named_partition(const char *part_name,
-                                         uint length)
+bool partition_info::add_named_partition(const char *part_name, size_t length)
 {
   HASH *part_name_hash;
   PART_NAME_DEF *part_def;
@@ -197,8 +196,7 @@ bool partition_info::add_named_partition(const char *part_name,
   @param part_elem  Partition element that matched.
 */
 
-bool partition_info::set_named_partition_bitmap(const char *part_name,
-                                                uint length)
+bool partition_info::set_named_partition_bitmap(const char *part_name, size_t length)
 {
   DBUG_ENTER("partition_info::set_named_partition_bitmap");
   bitmap_clear_all(&read_partitions);
@@ -419,7 +417,7 @@ char *partition_info::create_default_partition_names(THD *thd, uint part_no,
 char *partition_info::create_default_subpartition_name(THD *thd, uint subpart_no,
                                                const char *part_name)
 {
-  uint size_alloc= strlen(part_name) + MAX_PART_NAME_SIZE;
+  size_t size_alloc= strlen(part_name) + MAX_PART_NAME_SIZE;
   char *ptr= (char*) thd->calloc(size_alloc);
   DBUG_ENTER("create_default_subpartition_name");
 
diff --git a/sql/partition_info.h b/sql/partition_info.h
index 4a37008811a..26955682dda 100644
--- a/sql/partition_info.h
+++ b/sql/partition_info.h
@@ -324,7 +324,7 @@ public:
   ~partition_info() {}
 
   partition_info *get_clone(THD *thd);
-  bool set_named_partition_bitmap(const char *part_name, uint length);
+  bool set_named_partition_bitmap(const char *part_name, size_t length);
   bool set_partition_bitmaps(List<String> *partition_names);
   bool set_partition_bitmaps_from_table(TABLE_LIST *table_list);
   /* Answers the question if subpartitioning is used for a certain table */
@@ -388,7 +388,7 @@ private:
                                          const char *part_name);
   // FIXME: prune_partition_bitmaps() is duplicate of set_read_partitions()
   bool prune_partition_bitmaps(List<String> *partition_names);
-  bool add_named_partition(const char *part_name, uint length);
+  bool add_named_partition(const char *part_name, size_t length);
 public:
   bool set_read_partitions(List<char> *partition_names);
   bool has_unique_name(partition_element *element);
diff --git a/sql/password.c b/sql/password.c
index 47f4fd1d422..5e9684acb25 100644
--- a/sql/password.c
+++ b/sql/password.c
@@ -296,7 +296,7 @@ void make_password_from_salt_323(char *to, const ulong *salt)
     buf+len*2
 */
 
-char *octet2hex(char *to, const char *str, uint len)
+char *octet2hex(char *to, const char *str, size_t len)
 {
   const char *str_end= str + len; 
   for (; str != str_end; ++str)
diff --git a/sql/protocol.cc b/sql/protocol.cc
index fae399e66e2..032e79c9289 100644
--- a/sql/protocol.cc
+++ b/sql/protocol.cc
@@ -86,7 +86,7 @@ bool Protocol_binary::net_store_data_cs(const uchar *from, size_t length,
 {
   uint dummy_errors;
   /* Calculate maxumum possible result length */
-  uint conv_length= to_cs->mbmaxlen * length / from_cs->mbminlen;
+  size_t conv_length= to_cs->mbmaxlen * length / from_cs->mbminlen;
 
   if (conv_length > 250)
   {
@@ -106,8 +106,8 @@ bool Protocol_binary::net_store_data_cs(const uchar *from, size_t length,
             net_store_data((const uchar*) convert->ptr(), convert->length()));
   }
 
-  ulong packet_length= packet->length();
-  ulong new_length= packet_length + conv_length + 1;
+  size_t packet_length= packet->length();
+  size_t new_length= packet_length + conv_length + 1;
 
   if (new_length > packet->alloced_length() && packet->realloc(new_length))
     return 1;
@@ -480,8 +480,9 @@ bool net_send_error_packet(THD *thd, uint sql_errno, const char *err,
   - ulonglong for bigger numbers.
 */
 
-static uchar *net_store_length_fast(uchar *packet, uint length)
+static uchar *net_store_length_fast(uchar *packet, size_t length)
 {
+  DBUG_ASSERT(length < UINT_MAX16);
   if (length < 251)
   {
     *packet=(uchar) length;
@@ -661,7 +662,7 @@ void net_send_progress_packet(THD *thd)
 {
   uchar buff[200], *pos;
   const char *proc_info= thd->proc_info ? thd->proc_info : "";
-  uint length= strlen(proc_info);
+  size_t length= strlen(proc_info);
   ulonglong progress;
   DBUG_ENTER("net_send_progress_packet");
 
@@ -1015,7 +1016,7 @@ bool Protocol::store(const char *from, CHARSET_INFO *cs)
 {
   if (!from)
     return store_null();
-  uint length= strlen(from);
+  size_t length= strlen(from);
   return store(from, length, cs);
 }
 
diff --git a/sql/proxy_protocol.cc b/sql/proxy_protocol.cc
index d77e6ca8d34..dbdb1566bc7 100644
--- a/sql/proxy_protocol.cc
+++ b/sql/proxy_protocol.cc
@@ -210,14 +210,19 @@ int parse_proxy_protocol_header(NET *net, proxy_peer_info *peer_info)
   {
 #define PROXY_V2_HEADER_LEN 16
     /* read off 16 bytes of the header.*/
-    long len= vio_read(vio, hdr + pos, PROXY_V2_HEADER_LEN - pos);
+    ssize_t len= vio_read(vio, hdr + pos, PROXY_V2_HEADER_LEN - pos);
     if (len < 0)
       return -1;
     // 2 last bytes are the length in network byte order of the part following header
     ushort trail_len= ((ushort)hdr[PROXY_V2_HEADER_LEN-2] >> 8) + hdr[PROXY_V2_HEADER_LEN-1];
     if (trail_len > sizeof(hdr) - PROXY_V2_HEADER_LEN)
       return -1;
-    len= vio_read(vio,  hdr + PROXY_V2_HEADER_LEN, trail_len);
+    if (trail_len > 0)
+    {
+      len= vio_read(vio,  hdr + PROXY_V2_HEADER_LEN, trail_len);
+      if (len < 0)
+        return -1;
+    }
     pos= PROXY_V2_HEADER_LEN + trail_len;
     if (parse_v2_header(hdr, pos, peer_info))
       return -1;
@@ -230,11 +235,10 @@ int parse_proxy_protocol_header(NET *net, proxy_peer_info *peer_info)
       They will be treated as IPv4.
     */
     sockaddr_storage tmp;
-    int dst_len;
     memset(&tmp, 0, sizeof(tmp));
     vio_get_normalized_ip((const struct sockaddr *)&peer_info->peer_addr,
-      sizeof(sockaddr_storage), (struct sockaddr *)&tmp, &dst_len);
-    memcpy(&peer_info->peer_addr, &tmp, (size_t)dst_len);
+      sizeof(sockaddr_storage), (struct sockaddr *)&tmp);
+    memcpy(&peer_info->peer_addr, &tmp, sizeof(tmp));
   }
   return 0;
 }
@@ -464,10 +468,9 @@ bool is_proxy_protocol_allowed(const sockaddr *addr)
     case AF_INET:
     case AF_INET6:
       {
-      int len=
+      size_t len=
         (addr->sa_family == AF_INET)?sizeof(sockaddr_in):sizeof (sockaddr_in6);
-      int dst_len;
-      vio_get_normalized_ip(addr, len,normalized_addr, &dst_len);
+      vio_get_normalized_ip(addr, len,normalized_addr);
       }
       break;
     default:
diff --git a/sql/records.cc b/sql/records.cc
index 650a51f7f37..ac84ca84ab6 100644
--- a/sql/records.cc
+++ b/sql/records.cc
@@ -205,14 +205,14 @@ bool init_read_record(READ_RECORD *info,THD *thd, TABLE *table,
   if (addon_field)
   {
     info->rec_buf=    (uchar*) filesort->addon_buf.str;
-    info->ref_length= filesort->addon_buf.length;
+    info->ref_length= (uint)filesort->addon_buf.length;
     info->unpack=     filesort->unpack;
   }
   else
   {
     empty_record(table);
     info->record= table->record[0];
-    info->ref_length= table->file->ref_length;
+    info->ref_length= (uint)table->file->ref_length;
   }
   info->select=select;
   info->print_error=print_error;
diff --git a/sql/repl_failsafe.cc b/sql/repl_failsafe.cc
index 20290e8bad8..68c7158e9e5 100644
--- a/sql/repl_failsafe.cc
+++ b/sql/repl_failsafe.cc
@@ -115,7 +115,7 @@ void unregister_slave(THD* thd, bool only_mine, bool need_mutex)
     1	Error.   Error message sent to client
 */
 
-int register_slave(THD* thd, uchar* packet, uint packet_length)
+int register_slave(THD* thd, uchar* packet, size_t packet_length)
 {
   int res;
   SLAVE_INFO *si;
diff --git a/sql/repl_failsafe.h b/sql/repl_failsafe.h
index c3584fb17f2..967d81bcf0d 100644
--- a/sql/repl_failsafe.h
+++ b/sql/repl_failsafe.h
@@ -41,7 +41,7 @@ extern HASH slave_list;
 bool show_slave_hosts(THD* thd);
 void init_slave_list();
 void end_slave_list();
-int register_slave(THD* thd, uchar* packet, uint packet_length);
+int register_slave(THD* thd, uchar* packet, size_t packet_length);
 void unregister_slave(THD* thd, bool only_mine, bool need_mutex);
 
 #endif /* HAVE_REPLICATION */
diff --git a/sql/rpl_mi.cc b/sql/rpl_mi.cc
index 9661e0b0353..55a66719e56 100644
--- a/sql/rpl_mi.cc
+++ b/sql/rpl_mi.cc
@@ -1360,7 +1360,7 @@ Master_info_index::get_master_info(const LEX_CSTRING *connection_name,
 {
   Master_info *mi;
   char buff[MAX_CONNECTION_NAME+1], *res;
-  uint buff_length;
+  size_t buff_length;
   DBUG_ENTER("get_master_info");
   DBUG_PRINT("enter",
              ("connection_name: '%.*s'", (int) connection_name->length,
@@ -1914,7 +1914,7 @@ char *Domain_id_filter::as_string(enum_list_type type)
     return NULL;
 
   // Store the total number of elements followed by the individual elements.
-  ulong cur_len= sprintf(buf, "%u", ids->elements);
+  size_t cur_len= sprintf(buf, "%u", ids->elements);
   sz-= cur_len;
 
   for (uint i= 0; i < ids->elements; i++)
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index 9c1892e0c6c..58711078db6 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -414,7 +414,7 @@ void show_sql_type(enum_field_types type, uint16 metadata, String *str, CHARSET_
   case MYSQL_TYPE_VARCHAR_COMPRESSED:
     {
       CHARSET_INFO *cs= str->charset();
-      uint32 length=
+      size_t length=
         cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
                            "varchar(%u)%s", metadata,
                            type == MYSQL_TYPE_VARCHAR_COMPRESSED ? " compressed"
@@ -427,7 +427,7 @@ void show_sql_type(enum_field_types type, uint16 metadata, String *str, CHARSET_
     {
       CHARSET_INFO *cs= str->charset();
       int bit_length= 8 * (metadata >> 8) + (metadata & 0xFF);
-      uint32 length=
+      size_t length=
         cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
                            "bit(%d)", bit_length);
       str->length(length);
@@ -437,7 +437,7 @@ void show_sql_type(enum_field_types type, uint16 metadata, String *str, CHARSET_
   case MYSQL_TYPE_DECIMAL:
     {
       CHARSET_INFO *cs= str->charset();
-      uint32 length=
+      size_t length=
         cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
                            "decimal(%d,?)/*old*/", metadata);
       str->length(length);
@@ -447,7 +447,7 @@ void show_sql_type(enum_field_types type, uint16 metadata, String *str, CHARSET_
   case MYSQL_TYPE_NEWDECIMAL:
     {
       CHARSET_INFO *cs= str->charset();
-      uint32 length=
+      size_t length=
         cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
                            "decimal(%d,%d)", metadata >> 8, metadata & 0xff);
       str->length(length);
@@ -503,7 +503,7 @@ void show_sql_type(enum_field_types type, uint16 metadata, String *str, CHARSET_
       */
       CHARSET_INFO *cs= str->charset();
       uint bytes= (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff);
-      uint32 length=
+      size_t length=
         cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
                            "char(%d)", bytes / field_cs->mbmaxlen);
       str->length(length);
diff --git a/sql/semisync_master.cc b/sql/semisync_master.cc
index 5e83847edf9..3c88bdddad4 100644
--- a/sql/semisync_master.cc
+++ b/sql/semisync_master.cc
@@ -99,8 +99,7 @@ Active_tranx::~Active_tranx()
   m_num_entries      = 0;
 }
 
-unsigned int Active_tranx::calc_hash(const unsigned char *key,
-                                     unsigned int length)
+unsigned int Active_tranx::calc_hash(const unsigned char *key, size_t length)
 {
   unsigned int nr = 1, nr2 = 4;
 
diff --git a/sql/semisync_master.h b/sql/semisync_master.h
index a58c1a7ae6e..3b05d9e0348 100644
--- a/sql/semisync_master.h
+++ b/sql/semisync_master.h
@@ -310,7 +310,7 @@ private:
 
   inline void assert_lock_owner();
 
-  inline unsigned int calc_hash(const unsigned char *key,unsigned int length);
+  inline unsigned int calc_hash(const unsigned char *key, size_t length);
   unsigned int get_hash_value(const char *log_file_name, my_off_t log_file_pos);
 
   int compare(const char *log_file_name1, my_off_t log_file_pos1,
diff --git a/sql/semisync_master_ack_receiver.cc b/sql/semisync_master_ack_receiver.cc
index aa588a5f300..ac17c7de40b 100644
--- a/sql/semisync_master_ack_receiver.cc
+++ b/sql/semisync_master_ack_receiver.cc
@@ -252,7 +252,7 @@ void Ack_receiver::run()
 
       max_fd= get_slave_sockets(&read_fds, &slave_count);
       m_slaves_changed= false;
-      DBUG_PRINT("info", ("fd count %u, max_fd %d", slave_count, max_fd));
+      DBUG_PRINT("info", ("fd count %u, max_fd %d", slave_count,(int) max_fd));
     }
 
     struct timeval tv= {1, 0};
diff --git a/sql/semisync_slave.cc b/sql/semisync_slave.cc
index 2d77ee7b10c..86d0176dac1 100644
--- a/sql/semisync_slave.cc
+++ b/sql/semisync_slave.cc
@@ -148,9 +148,9 @@ void Repl_semi_sync_slave::kill_connection(MYSQL *mysql)
       mysql_close(kill_mysql);
     return;
   }
-  uint kill_buffer_length = my_snprintf(kill_buffer, 30, "KILL %lu",
+  size_t kill_buffer_length = my_snprintf(kill_buffer, 30, "KILL %lu",
                                         mysql->thread_id);
-  mysql_real_query(kill_mysql, kill_buffer, kill_buffer_length);
+  mysql_real_query(kill_mysql, kill_buffer, (ulong)kill_buffer_length);
   mysql_close(kill_mysql);
 }
 
@@ -165,7 +165,7 @@ int Repl_semi_sync_slave::request_transmit(Master_info *mi)
     return 0;
 
   query= "SHOW VARIABLES LIKE 'rpl_semi_sync_master_enabled'";
-  if (mysql_real_query(mysql, query, strlen(query)) ||
+  if (mysql_real_query(mysql, query, (ulong)strlen(query)) ||
       !(res= mysql_store_result(mysql)))
   {
     sql_print_error("Execution failed on master: %s, error :%s", query, mysql_error(mysql));
@@ -190,7 +190,7 @@ int Repl_semi_sync_slave::request_transmit(Master_info *mi)
    replication
   */
   query= "SET @rpl_semi_sync_slave= 1";
-  if (mysql_real_query(mysql, query, strlen(query)))
+  if (mysql_real_query(mysql, query, (ulong)strlen(query)))
   {
     sql_print_error("Set 'rpl_semi_sync_slave=1' on master failed");
     return 1;
@@ -212,7 +212,7 @@ int Repl_semi_sync_slave::slave_reply(Master_info *mi)
                      + REPLY_BINLOG_POS_LEN
                      + REPLY_BINLOG_NAME_LEN];
   int reply_res = 0;
-  int name_len = strlen(binlog_filename);
+  size_t name_len = strlen(binlog_filename);
 
   DBUG_ENTER("Repl_semi_sync_slave::slave_reply");
 
diff --git a/sql/session_tracker.cc b/sql/session_tracker.cc
index 51888913983..b59475645fa 100644
--- a/sql/session_tracker.cc
+++ b/sql/session_tracker.cc
@@ -419,7 +419,6 @@ bool Session_sysvars_tracker::vars_list::parse_var_list(THD *thd,
   {
     sys_var *svar;
     LEX_CSTRING var;
-    uint not_used;
 
     lasts= (char *) memchr(token, separator, rest);
 
@@ -433,7 +432,7 @@ bool Session_sysvars_tracker::vars_list::parse_var_list(THD *thd,
       var.length= rest;
 
     /* Remove leading/trailing whitespace. */
-    trim_whitespace(char_set, &var, &not_used);
+    trim_whitespace(char_set, &var);
 
     if(!strcmp(var.str, "*"))
     {
@@ -501,7 +500,6 @@ bool Session_sysvars_tracker::check_var_list(THD *thd,
   for (;;)
   {
     LEX_CSTRING var;
-    uint not_used;
 
     lasts= (char *) memchr(token, separator, rest);
 
@@ -515,7 +513,7 @@ bool Session_sysvars_tracker::check_var_list(THD *thd,
       var.length= rest;
 
     /* Remove leading/trailing whitespace. */
-    trim_whitespace(char_set, &var, &not_used);
+    trim_whitespace(char_set, &var);
 
     if(!strcmp(var.str, "*") &&
        !find_sys_var_ex(thd, var.str, var.length, throw_error, true))
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 91224421117..1bdbd4e1f6e 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -673,7 +673,7 @@ SHOW_VAR* enumerate_sys_vars(THD *thd, bool sorted, enum enum_var_type scope)
     0           Unknown variable (error message is given)
 */
 
-sys_var *intern_find_sys_var(const char *str, uint length)
+sys_var *intern_find_sys_var(const char *str, size_t length)
 {
   sys_var *var;
 
@@ -853,7 +853,7 @@ set_var::set_var(THD *thd, enum_var_type type_arg, sys_var *var_arg,
     // names are utf8
     if (!(value= new (thd->mem_root) Item_string_sys(thd,
                                                      item->field_name.str,
-                                                     item->field_name.length)))
+                                                     (uint)item->field_name.length)))
       value=value_arg;                        /* Give error message later */
   }
   else
diff --git a/sql/slave.cc b/sql/slave.cc
index d969f1c20b8..86c9105e1a6 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -1590,7 +1590,7 @@ const char *print_slave_db_safe(const char* db)
 int init_strvar_from_file(char *var, int max_size, IO_CACHE *f,
                                  const char *default_val)
 {
-  uint length;
+  size_t length;
   DBUG_ENTER("init_strvar_from_file");
 
   if ((length=my_b_gets(f,var, max_size)))
@@ -2200,7 +2200,7 @@ when it try to get the value of TIME_ZONE global variable from master.";
                       if (++dbug_count < 3)
                         goto heartbeat_network_error;
                     });
-    if (mysql_real_query(mysql, query, strlen(query)))
+    if (mysql_real_query(mysql, query, (ulong)strlen(query)))
     {
       if (check_io_slave_killed(mi, NULL))
         goto slave_killed_err;
@@ -2248,7 +2248,7 @@ when it try to get the value of TIME_ZONE global variable from master.";
       Once the first FD will be received its alg descriptor will replace
       the being queried one.
     */
-    rc= mysql_real_query(mysql, query, strlen(query));
+    rc= mysql_real_query(mysql, query,(ulong)strlen(query));
     if (rc != 0)
     {
       if (check_io_slave_killed(mi, NULL))
@@ -2826,7 +2826,7 @@ int register_slave_on_master(MYSQL* mysql, Master_info *mi,
                              bool *suppress_warnings)
 {
   uchar buf[1024], *pos= buf;
-  uint report_host_len=0, report_user_len=0, report_password_len=0;
+  size_t report_host_len=0, report_user_len=0, report_password_len=0;
   DBUG_ENTER("register_slave_on_master");
 
   *suppress_warnings= FALSE;
@@ -2834,7 +2834,7 @@ int register_slave_on_master(MYSQL* mysql, Master_info *mi,
     report_host_len= strlen(report_host);
   if (report_host_len > HOSTNAME_LENGTH)
   {
-    sql_print_warning("The length of report_host is %d. "
+    sql_print_warning("The length of report_host is %zu. "
                       "It is larger than the max length(%d), so this "
                       "slave cannot be registered to the master.",
                       report_host_len, HOSTNAME_LENGTH);
@@ -2845,7 +2845,7 @@ int register_slave_on_master(MYSQL* mysql, Master_info *mi,
     report_user_len= strlen(report_user);
   if (report_user_len > USERNAME_LENGTH)
   {
-    sql_print_warning("The length of report_user is %d. "
+    sql_print_warning("The length of report_user is %zu. "
                       "It is larger than the max length(%d), so this "
                       "slave cannot be registered to the master.",
                       report_user_len, USERNAME_LENGTH);
@@ -2856,7 +2856,7 @@ int register_slave_on_master(MYSQL* mysql, Master_info *mi,
     report_password_len= strlen(report_password);
   if (report_password_len > MAX_PASSWORD_LENGTH)
   {
-    sql_print_warning("The length of report_password is %d. "
+    sql_print_warning("The length of report_password is %zu. "
                       "It is larger than the max length(%d), so this "
                       "slave cannot be registered to the master.",
                       report_password_len, MAX_PASSWORD_LENGTH);
@@ -2877,7 +2877,7 @@ int register_slave_on_master(MYSQL* mysql, Master_info *mi,
   /* The master will fill in master_id */
   int4store(pos, 0);                    pos+= 4;
 
-  if (simple_command(mysql, COM_REGISTER_SLAVE, buf, (size_t) (pos- buf), 0))
+  if (simple_command(mysql, COM_REGISTER_SLAVE, buf, (ulong) (pos- buf), 0))
   {
     if (mysql_errno(mysql) == ER_NET_READ_INTERRUPTED)
     {
@@ -3144,7 +3144,7 @@ void show_master_info_get_fields(THD *thd, List<Item> *field_list,
                           mem_root);
     field_list->push_back(new (mem_root)
                           Item_empty_string(thd, "Gtid_Slave_Pos",
-                                            gtid_pos_length),
+                                            (uint)gtid_pos_length),
                           mem_root);
   }
   DBUG_VOID_RETURN;
diff --git a/sql/sp_cache.cc b/sql/sp_cache.cc
index 0fd6fe92d1f..4f7cf1557e4 100644
--- a/sql/sp_cache.cc
+++ b/sql/sp_cache.cc
@@ -48,7 +48,7 @@ public:
     return my_hash_insert(&m_hashtable, (const uchar *)sp);
   }
 
-  inline sp_head *lookup(char *name, uint namelen)
+  inline sp_head *lookup(char *name, size_t namelen)
   {
     return (sp_head *) my_hash_search(&m_hashtable, (const uchar *)name,
                                       namelen);
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index d451f25db8a..b405dadb9fe 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -604,7 +604,6 @@ sp_head::set_stmt_end(THD *thd)
 {
   Lex_input_stream *lip= & thd->m_parser_state->m_lip; /* shortcut */
   const char *end_ptr= lip->get_cpp_ptr(); /* shortcut */
-  uint not_used;
 
   /* Make the string of parameters. */
 
@@ -622,7 +621,7 @@ sp_head::set_stmt_end(THD *thd)
 
   m_body.length= end_ptr - m_body_begin;
   m_body.str= thd->strmake(m_body_begin, m_body.length);
-  trim_whitespace(thd->charset(), &m_body, &not_used);
+  trim_whitespace(thd->charset(), &m_body);
 
   /* Make the string of UTF-body. */
 
@@ -630,7 +629,7 @@ sp_head::set_stmt_end(THD *thd)
 
   m_body_utf8.length= lip->get_body_utf8_length();
   m_body_utf8.str= thd->strmake(lip->get_body_utf8_str(), m_body_utf8.length);
-  trim_whitespace(thd->charset(), &m_body_utf8, &not_used);
+  trim_whitespace(thd->charset(), &m_body_utf8);
 
   /*
     Make the string of whole stored-program-definition query (in the
@@ -639,7 +638,7 @@ sp_head::set_stmt_end(THD *thd)
 
   m_defstr.length= end_ptr - lip->get_cpp_buf();
   m_defstr.str= thd->strmake(lip->get_cpp_buf(), m_defstr.length);
-  trim_whitespace(thd->charset(), &m_defstr, &not_used);
+  trim_whitespace(thd->charset(), &m_defstr);
 }
 
 
@@ -875,7 +874,7 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str)
 
   rewritables.sort(cmp_rqp_locations);
 
-  thd->query_name_consts= rewritables.elements();
+  thd->query_name_consts= (uint)rewritables.elements();
 
   for (Rewritable_query_parameter **rqp= rewritables.front();
        rqp <= rewritables.back(); rqp++)
@@ -898,7 +897,7 @@ subst_spvars(THD *thd, sp_instr *instr, LEX_STRING *query_str)
             <db_name>     Name of current database
             <flags>       Flags struct
   */
-  int buf_len= (qbuf.length() + 1 + QUERY_CACHE_DB_LENGTH_SIZE +
+  size_t buf_len= (qbuf.length() + 1 + QUERY_CACHE_DB_LENGTH_SIZE +
                 thd->db.length + QUERY_CACHE_FLAGS_SIZE + 1);
   if ((pbuf= (char *) alloc_root(thd->mem_root, buf_len)))
   {
@@ -2332,7 +2331,7 @@ sp_head::backpatch_goto(THD *thd, sp_label *lab,sp_label *lab_begin_block)
       }
       if (bp->instr_type == CPOP)
       {
-        int n= lab->ctx->diff_cursors(lab_begin_block->ctx, true);
+        uint n= lab->ctx->diff_cursors(lab_begin_block->ctx, true);
         if (n == 0)
         {
           // Remove cpop instr
@@ -2349,7 +2348,7 @@ sp_head::backpatch_goto(THD *thd, sp_label *lab,sp_label *lab_begin_block)
       }
       if (bp->instr_type == HPOP)
       {
-        int n= lab->ctx->diff_handlers(lab_begin_block->ctx, true);
+        uint n= lab->ctx->diff_handlers(lab_begin_block->ctx, true);
         if (n == 0)
         {
           // Remove hpop instr
@@ -2655,7 +2654,7 @@ sp_head::show_create_routine(THD *thd, const Sp_handler *sph)
                    Item_empty_string(thd, col1_caption, NAME_CHAR_LEN),
                    thd->mem_root);
   fields.push_back(new (mem_root)
-                   Item_empty_string(thd, "sql_mode", sql_mode.length),
+                   Item_empty_string(thd, "sql_mode", (uint)sql_mode.length),
                    thd->mem_root);
 
   {
@@ -2666,7 +2665,7 @@ sp_head::show_create_routine(THD *thd, const Sp_handler *sph)
 
     Item_empty_string *stmt_fld=
       new (mem_root) Item_empty_string(thd, col3_caption,
-                            MY_MAX(m_defstr.length, 1024));
+                            (uint)MY_MAX(m_defstr.length, 1024));
 
     stmt_fld->maybe_null= TRUE;
 
@@ -3326,7 +3325,7 @@ sp_instr_stmt::execute(THD *thd, uint *nextp)
 void
 sp_instr_stmt::print(String *str)
 {
-  uint i, len;
+  size_t i, len;
 
   /* stmt CMD "..." */
   if (str->reserve(SP_STMT_PRINT_MAXLEN+SP_INSTR_UINT_MAXLEN+8))
@@ -3398,7 +3397,7 @@ void
 sp_instr_set::print(String *str)
 {
   /* set name@offset ... */
-  int rsrv = SP_INSTR_UINT_MAXLEN+6;
+  size_t rsrv = SP_INSTR_UINT_MAXLEN+6;
   sp_variable *var = m_ctx->find_variable(m_offset);
 
   /* 'var' should always be non-null, but just in case... */
@@ -3438,7 +3437,7 @@ void
 sp_instr_set_row_field::print(String *str)
 {
   /* set name@offset[field_offset] ... */
-  int rsrv= SP_INSTR_UINT_MAXLEN + 6 + 6 + 3;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN + 6 + 6 + 3;
   sp_variable *var= m_ctx->find_variable(m_offset);
   DBUG_ASSERT(var);
   DBUG_ASSERT(var->field_def.is_row());
@@ -3484,7 +3483,7 @@ void
 sp_instr_set_row_field_by_name::print(String *str)
 {
   /* set name.field@offset["field"] ... */
-  int rsrv= SP_INSTR_UINT_MAXLEN + 6 + 6 + 3 + 2;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN + 6 + 6 + 3 + 2;
   sp_variable *var= m_ctx->find_variable(m_offset);
   DBUG_ASSERT(var);
   DBUG_ASSERT(var->field_def.is_table_rowtype_ref() ||
@@ -3962,7 +3961,7 @@ sp_instr_cpush::print(String *str)
   const LEX_CSTRING *cursor_name= m_ctx->find_cursor(m_cursor);
 
   /* cpush name@offset */
-  uint rsrv= SP_INSTR_UINT_MAXLEN+7;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN+7;
 
   if (cursor_name)
     rsrv+= cursor_name->length;
@@ -4050,7 +4049,7 @@ sp_instr_copen::print(String *str)
   const LEX_CSTRING *cursor_name= m_ctx->find_cursor(m_cursor);
 
   /* copen name@offset */
-  uint rsrv= SP_INSTR_UINT_MAXLEN+7;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN+7;
 
   if (cursor_name)
     rsrv+= cursor_name->length;
@@ -4092,7 +4091,7 @@ sp_instr_cclose::print(String *str)
   const LEX_CSTRING *cursor_name= m_ctx->find_cursor(m_cursor);
 
   /* cclose name@offset */
-  uint rsrv= SP_INSTR_UINT_MAXLEN+8;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN+8;
 
   if (cursor_name)
     rsrv+= cursor_name->length;
@@ -4135,7 +4134,7 @@ sp_instr_cfetch::print(String *str)
   const LEX_CSTRING *cursor_name= m_ctx->find_cursor(m_cursor);
 
   /* cfetch name@offset vars... */
-  uint rsrv= SP_INSTR_UINT_MAXLEN+8;
+  size_t rsrv= SP_INSTR_UINT_MAXLEN+8;
 
   if (cursor_name)
     rsrv+= cursor_name->length;
@@ -4390,7 +4389,7 @@ typedef struct st_sp_table
       db_name\0table_name\0        - for temporary tables
   */
   LEX_STRING qname;
-  uint db_length, table_name_length;
+  size_t db_length, table_name_length;
   bool temp;               /* true if corresponds to a temporary table */
   thr_lock_type lock_type; /* lock type used for prelocking */
   uint lock_count;
diff --git a/sql/sp_head.h b/sql/sp_head.h
index e89d0d14a95..23717513af9 100644
--- a/sql/sp_head.h
+++ b/sql/sp_head.h
@@ -731,7 +731,7 @@ public:
   void set_info(longlong created, longlong modified,
 		const st_sp_chistics &chistics, sql_mode_t sql_mode);
 
-  void set_definer(const char *definer, uint definerlen)
+  void set_definer(const char *definer, size_t definerlen)
   {
     AUTHID tmp;
     tmp.parse(definer, definerlen);
diff --git a/sql/sp_pcontext.cc b/sql/sp_pcontext.cc
index d7bc26901b0..83d674e7500 100644
--- a/sql/sp_pcontext.cc
+++ b/sql/sp_pcontext.cc
@@ -171,12 +171,12 @@ uint sp_pcontext::diff_handlers(const sp_pcontext *ctx, bool exclusive) const
 
   while (pctx && pctx != ctx)
   {
-    n+= pctx->m_handlers.elements();
+    n+= (uint)pctx->m_handlers.elements();
     last_ctx= pctx;
     pctx= pctx->parent_context();
   }
   if (pctx)
-    return (exclusive && last_ctx ? n - last_ctx->m_handlers.elements() : n);
+    return (exclusive && last_ctx ? n -(uint) last_ctx->m_handlers.elements() : n);
   return 0;			// Didn't find ctx
 }
 
@@ -189,12 +189,12 @@ uint sp_pcontext::diff_cursors(const sp_pcontext *ctx, bool exclusive) const
 
   while (pctx && pctx != ctx)
   {
-    n+= pctx->m_cursors.elements();
+    n+= (uint)pctx->m_cursors.elements();
     last_ctx= pctx;
     pctx= pctx->parent_context();
   }
   if (pctx)
-    return  (exclusive && last_ctx ? n - last_ctx->m_cursors.elements() : n);
+    return  (exclusive && last_ctx ? (uint)(n - last_ctx->m_cursors.elements()) : n);
   return 0;			// Didn't find ctx
 }
 
@@ -202,7 +202,7 @@ uint sp_pcontext::diff_cursors(const sp_pcontext *ctx, bool exclusive) const
 sp_variable *sp_pcontext::find_variable(const LEX_CSTRING *name,
                                         bool current_scope_only) const
 {
-  uint i= m_vars.elements() - m_pboundary;
+  size_t i= m_vars.elements() - m_pboundary;
 
   while (i--)
   {
@@ -392,7 +392,7 @@ bool sp_pcontext::add_condition(THD *thd,
 sp_condition_value *sp_pcontext::find_condition(const LEX_CSTRING *name,
                                                 bool current_scope_only) const
 {
-  uint i= m_conditions.elements();
+  size_t i= m_conditions.elements();
 
   while (i--)
   {
@@ -605,7 +605,7 @@ const sp_pcursor *sp_pcontext::find_cursor(const LEX_CSTRING *name,
                                            uint *poff,
                                            bool current_scope_only) const
 {
-  uint i= m_cursors.elements();
+  uint i= (uint)m_cursors.elements();
 
   while (i--)
   {
diff --git a/sql/sp_pcontext.h b/sql/sp_pcontext.h
index 990ad35cb57..6a6920d89e1 100644
--- a/sql/sp_pcontext.h
+++ b/sql/sp_pcontext.h
@@ -673,7 +673,7 @@ public:
   { return m_cursor_offset; }
 
   uint frame_cursor_count() const
-  { return m_cursors.elements(); }
+  { return (uint)m_cursors.elements(); }
 
   uint max_cursor_index() const
   { return m_max_cursor_index + (uint)m_cursors.elements(); }
diff --git a/sql/sp_rcontext.cc b/sql/sp_rcontext.cc
index eab0e10a3f0..4009f8dce30 100644
--- a/sql/sp_rcontext.cc
+++ b/sql/sp_rcontext.cc
@@ -413,7 +413,7 @@ bool sp_rcontext::push_cursor(THD *thd, sp_lex_keeper *lex_keeper)
 }
 
 
-void sp_rcontext::pop_cursors(uint count)
+void sp_rcontext::pop_cursors(size_t count)
 {
   DBUG_ASSERT(m_ccount >= count);
 
diff --git a/sql/sp_rcontext.h b/sql/sp_rcontext.h
index 8a03dca435d..c4f4cf182da 100644
--- a/sql/sp_rcontext.h
+++ b/sql/sp_rcontext.h
@@ -305,7 +305,7 @@ public:
   /// Pop and delete given number of sp_cursor instance from the cursor stack.
   ///
   /// @param count Number of cursors to pop & delete.
-  void pop_cursors(uint count);
+  void pop_cursors(size_t count);
 
   void pop_all_cursors()
   { pop_cursors(m_ccount); }
diff --git a/sql/spatial.cc b/sql/spatial.cc
index 2a07ef2ecbe..255ba3f0647 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -142,7 +142,7 @@ static void get_point(double *x, double *y, const char *data)
 
 /***************************** Geometry *******************************/
 
-Geometry::Class_info *Geometry::find_class(const char *name, uint32 len)
+Geometry::Class_info *Geometry::find_class(const char *name, size_t len)
 {
   for (Class_info **cur_rt= ci_collection;
        cur_rt < ci_collection_end; cur_rt++)
diff --git a/sql/spatial.h b/sql/spatial.h
index 901544b6916..5818607de26 100644
--- a/sql/spatial.h
+++ b/sql/spatial.h
@@ -347,7 +347,7 @@ protected:
     return ((type_id < wkb_point) || (type_id > wkb_last)) ?
       NULL : ci_collection[type_id];
   }  
-  static Class_info *find_class(const char *name, uint32 len);
+  static Class_info *find_class(const char *name, size_t len);
   const char *append_points(String *txt, uint32 n_points,
 			    const char *data, uint32 offset) const;
   bool create_point(String *result, const char *data) const;
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 3964424af62..b47dbef0dc5 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -258,7 +258,7 @@ class ACL_USER :public ACL_USER_BASE
 {
 public:
   acl_host_and_ip host;
-  uint hostname_length;
+  size_t hostname_length;
   USER_RESOURCES user_resource;
   uint8 salt[SCRAMBLE_LENGTH + 1];       // scrambled password in binary form
   uint8 salt_len;        // 0 - no password, 4 - 3.20, 8 - 4.0,  20 - 4.1.1
@@ -744,7 +744,7 @@ static ACL_ROLE *find_acl_role(const char *user);
 static ROLE_GRANT_PAIR *find_role_grant_pair(const LEX_CSTRING *u, const LEX_CSTRING *h, const LEX_CSTRING *r);
 static ACL_USER_BASE *find_acl_user_base(const char *user, const char *host);
 static bool update_user_table(THD *, const User_table &, const char *, const char *, const
-                              char *, uint);
+                              char *, size_t new_password_len);
 static bool acl_load(THD *thd, const Grant_tables& grant_tables);
 static inline void get_grantor(THD *thd, char* grantor);
 static bool add_role_user_mapping(const char *uname, const char *hname, const char *rname);
@@ -1545,7 +1545,7 @@ static bool validate_password(LEX_USER *user, THD *thd)
 */
 
 static void
-set_user_salt(ACL_USER *acl_user, const char *password, uint password_len)
+set_user_salt(ACL_USER *acl_user, const char *password, size_t password_len)
 {
   if (password_len == SCRAMBLED_PASSWORD_CHAR_LENGTH)
   {
@@ -1768,7 +1768,7 @@ bool acl_init(bool dont_read_acl_tables)
   Choose from either native or old password plugins when assigning a password
 */
 
-static bool set_user_plugin (ACL_USER *user, int password_len)
+static bool set_user_plugin (ACL_USER *user, size_t password_len)
 {
   switch (password_len)
   {
@@ -1962,7 +1962,7 @@ static bool acl_load(THD *thd, const Grant_tables& tables)
     char *password= const_cast<char*>("");
     if (user_table.password())
       password= get_field(&acl_memroot, user_table.password());
-    uint password_len= safe_strlen(password);
+    size_t password_len= safe_strlen(password);
     user.auth_string.str= safe_str(password);
     user.auth_string.length= password_len;
     set_user_salt(&user, password, password_len);
@@ -2715,7 +2715,7 @@ static void acl_update_role(const char *rolename, ulong privileges)
 
 
 static void acl_update_user(const char *user, const char *host,
-			    const char *password, uint password_len,
+			    const char *password, size_t password_len,
 			    enum SSL_type ssl_type,
 			    const char *ssl_cipher,
 			    const char *x509_issuer,
@@ -2793,7 +2793,7 @@ static void acl_insert_role(const char *rolename, ulong privileges)
 
 
 static void acl_insert_user(const char *user, const char *host,
-			    const char *password, uint password_len,
+			    const char *password, size_t password_len,
 			    enum SSL_type ssl_type,
 			    const char *ssl_cipher,
 			    const char *x509_issuer,
@@ -3409,6 +3409,7 @@ bool change_password(THD *thd, LEX_USER *user)
     acl_user->auth_string.str= strmake_root(&acl_memroot, user->pwhash.str, user->pwhash.length);
     acl_user->auth_string.length= user->pwhash.length;
     set_user_salt(acl_user, user->pwhash.str, user->pwhash.length);
+
     set_user_plugin(acl_user, user->pwhash.length);
   }
   else
@@ -3869,8 +3870,7 @@ bool hostname_requires_resolving(const char *hostname)
 
 
 void set_authentication_plugin_from_password(const User_table& user_table,
-                                             const char* password,
-                                             uint password_length)
+                                             const char* password, size_t password_length)
 {
   if (password_length == SCRAMBLED_PASSWORD_CHAR_LENGTH)
   {
@@ -3904,7 +3904,7 @@ void set_authentication_plugin_from_password(const User_table& user_table,
 
 static bool update_user_table(THD *thd, const User_table& user_table,
                               const char *host, const char *user,
-                              const char *new_password, uint new_password_len)
+                              const char *new_password, size_t new_password_len)
 {
   char user_key[MAX_KEY_LENGTH];
   int error;
@@ -5016,7 +5016,7 @@ table_hash_search(const char *host, const char *ip, const char *db,
 
 
 static GRANT_COLUMN *
-column_hash_search(GRANT_TABLE *t, const char *cname, uint length)
+column_hash_search(GRANT_TABLE *t, const char *cname, size_t length)
 {
   if (!my_hash_inited(&t->hash_columns))
     return (GRANT_COLUMN*) 0;
@@ -7775,7 +7775,7 @@ err:
 
 bool check_grant_column(THD *thd, GRANT_INFO *grant,
 			const char *db_name, const char *table_name,
-			const char *name, uint length,  Security_context *sctx)
+			const char *name, size_t length,  Security_context *sctx)
 {
   GRANT_TABLE *grant_table;
   GRANT_TABLE *grant_table_role;
@@ -7870,7 +7870,7 @@ err:
 */
 
 bool check_column_grant_in_table_ref(THD *thd, TABLE_LIST * table_ref,
-                                     const char *name, uint length)
+                                     const char *name, size_t length)
 {
   GRANT_INFO *grant;
   const char *db_name;
@@ -12414,7 +12414,7 @@ static bool find_mpvio_user(MPVIO_EXT *mpvio)
   }
 
   mpvio->auth_info.user_name= sctx->user;
-  mpvio->auth_info.user_name_length= strlen(sctx->user);
+  mpvio->auth_info.user_name_length= (uint)strlen(sctx->user);
   mpvio->auth_info.auth_string= mpvio->acl_user->auth_string.str;
   mpvio->auth_info.auth_string_length= (unsigned long) mpvio->acl_user->auth_string.length;
   strmake_buf(mpvio->auth_info.authenticated_as, safe_str(mpvio->acl_user->user.str));
@@ -12452,7 +12452,7 @@ read_client_connect_attrs(char **ptr, char *end, CHARSET_INFO *from_cs)
   if (length > 65535)
     return true;
 
-  if (PSI_CALL_set_thread_connect_attrs(*ptr, (size_t)length, from_cs) &&
+  if (PSI_CALL_set_thread_connect_attrs(*ptr, (uint)length, from_cs) &&
       current_thd->variables.log_warnings)
     sql_print_warning("Connection attributes of length %llu were truncated",
                       length);
@@ -12497,7 +12497,7 @@ static bool parse_com_change_user_packet(MPVIO_EXT *mpvio, uint packet_length)
     *passwd > 127 and become 2**32-127+ after casting to uint.
   */
   uint passwd_len= (thd->client_capabilities & CLIENT_SECURE_CONNECTION ?
-                    (uchar) (*passwd++) : strlen(passwd));
+                    (uchar) (*passwd++) : (uint)strlen(passwd));
 
   db+= passwd_len + 1;
   /*
@@ -12511,7 +12511,7 @@ static bool parse_com_change_user_packet(MPVIO_EXT *mpvio, uint packet_length)
     DBUG_RETURN (1);
   }
 
-  uint db_len= strlen(db);
+  size_t db_len= strlen(db);
 
   char *next_field= db + db_len + 1;
 
@@ -12711,7 +12711,7 @@ static ulong parse_client_handshake_packet(MPVIO_EXT *mpvio,
 
   char *user= end;
   char *passwd= strend(user)+1;
-  uint user_len= (uint)(passwd - user - 1), db_len;
+  size_t user_len= (size_t)(passwd - user - 1), db_len;
   char *db= passwd;
   char user_buff[USERNAME_LENGTH + 1];	// buffer to store user in utf8
   uint dummy_errors;
@@ -12854,7 +12854,7 @@ static ulong parse_client_handshake_packet(MPVIO_EXT *mpvio,
                     plugin_name(mpvio->plugin)) != 0)
   {
     mpvio->cached_client_reply.pkt= passwd;
-    mpvio->cached_client_reply.pkt_len= passwd_len;
+    mpvio->cached_client_reply.pkt_len= (uint)passwd_len;
     mpvio->cached_client_reply.plugin= client_plugin;
     mpvio->status= MPVIO_EXT::RESTART;
     return packet_error;
@@ -12883,7 +12883,7 @@ static ulong parse_client_handshake_packet(MPVIO_EXT *mpvio,
   }
 
   *buff= (uchar*) passwd;
-  return passwd_len;
+  return (ulong)passwd_len;
 #else
   return 0;
 #endif
@@ -13529,8 +13529,8 @@ bool acl_authenticate(THD *thd, uint com_change_user_pkt_len)
     my_ok(thd);
 
   PSI_CALL_set_thread_user_host
-    (thd->main_security_ctx.user, strlen(thd->main_security_ctx.user),
-    thd->main_security_ctx.host_or_ip, strlen(thd->main_security_ctx.host_or_ip));
+    (thd->main_security_ctx.user, (uint)strlen(thd->main_security_ctx.user),
+    thd->main_security_ctx.host_or_ip, (uint)strlen(thd->main_security_ctx.host_or_ip));
 
   /* Ready to handle queries */
   DBUG_RETURN(0);
@@ -13660,7 +13660,7 @@ static int old_password_authenticate(MYSQL_PLUGIN_VIO *vio,
     We need to figure out the correct scramble length here.
   */
   if (pkt_len == SCRAMBLE_LENGTH_323 + 1)
-    pkt_len= strnlen((char*)pkt, pkt_len);
+    pkt_len= (int)strnlen((char*)pkt, pkt_len);
 
   if (pkt_len == 0) /* no password */
     return info->auth_string[0] ? CR_AUTH_USER_CREDENTIALS : CR_OK;
diff --git a/sql/sql_acl.h b/sql/sql_acl.h
index bafb9ca23d8..a608ef0dd77 100644
--- a/sql/sql_acl.h
+++ b/sql/sql_acl.h
@@ -237,9 +237,9 @@ bool check_grant(THD *thd, ulong want_access, TABLE_LIST *tables,
                  bool any_combination_will_do, uint number, bool no_errors);
 bool check_grant_column (THD *thd, GRANT_INFO *grant,
                          const char *db_name, const char *table_name,
-                         const char *name, uint length, Security_context *sctx);
+                         const char *name, size_t length, Security_context *sctx);
 bool check_column_grant_in_table_ref(THD *thd, TABLE_LIST * table_ref,
-                                     const char *name, uint length);
+                                     const char *name, size_t length);
 bool check_grant_all_columns(THD *thd, ulong want_access,
                              Field_iterator_table_ref *fields);
 bool check_grant_routine(THD *thd, ulong want_access,
diff --git a/sql/sql_array.h b/sql/sql_array.h
index 341ea9a651b..cad7b0e1c48 100644
--- a/sql/sql_array.h
+++ b/sql/sql_array.h
@@ -191,9 +191,10 @@ public:
     return *((Elem*)pop_dynamic(&array));
   }
 
-  void del(uint idx)
+  void del(size_t idx)
   {
-    delete_dynamic_element(&array, idx);
+    DBUG_ASSERT(idx <= array.max_element);
+    delete_dynamic_element(&array, (uint)idx);
   }
 
   size_t elements() const
@@ -204,7 +205,7 @@ public:
   void elements(size_t num_elements)
   {
     DBUG_ASSERT(num_elements <= array.max_element);
-    array.elements= num_elements;
+    array.elements= (uint)num_elements;
   }
 
   void clear()
@@ -220,12 +221,12 @@ public:
   bool resize(size_t new_size, Elem default_val)
   {
     size_t old_size= elements();
-    if (allocate_dynamic(&array, new_size))
+    if (allocate_dynamic(&array, (uint)new_size))
       return true;
     
     if (new_size > old_size)
     {
-      set_dynamic(&array, (uchar*)&default_val, new_size - 1);
+      set_dynamic(&array, (uchar*)&default_val, (uint)(new_size - 1));
       /*for (size_t i= old_size; i != new_size; i++)
       {
         at(i)= default_val;
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 5fbf4ba4c81..0d76e469a82 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -245,7 +245,7 @@ static my_bool list_open_tables_callback(TDC_element *element,
                                          list_open_tables_arg *arg)
 {
   const char *db= (char*) element->m_key;
-  uint db_length= strlen(db);
+  size_t db_length= strlen(db);
   const char *table_name= db + db_length + 1;
 
   if (arg->db && my_strcasecmp(system_charset_info, arg->db, db))
@@ -644,7 +644,7 @@ close_all_tables_for_name(THD *thd, TABLE_SHARE *share,
   DBUG_ASSERT(!share->tmp_table);
 
   char key[MAX_DBKEY_LENGTH];
-  uint key_length= share->table_cache_key.length;
+  size_t key_length= share->table_cache_key.length;
   const char *db= key;
   const char *table_name= db + share->db.length + 1;
 
@@ -2404,7 +2404,7 @@ bool
 Locked_tables_list::reopen_tables(THD *thd)
 {
   Open_table_context ot_ctx(thd, MYSQL_OPEN_REOPEN);
-  size_t reopen_count= 0;
+  uint reopen_count= 0;
   MYSQL_LOCK *lock;
   MYSQL_LOCK *merged_lock;
   DBUG_ENTER("Locked_tables_list::reopen_tables");
@@ -5424,7 +5424,7 @@ static void update_field_dependencies(THD *thd, Field *field, TABLE *table)
 
 static Field *
 find_field_in_view(THD *thd, TABLE_LIST *table_list,
-                   const char *name, uint length,
+                   const char *name, size_t length,
                    const char *item_name, Item **ref,
                    bool register_tree_change)
 {
@@ -5505,8 +5505,7 @@ find_field_in_view(THD *thd, TABLE_LIST *table_list,
 */
 
 static Field *
-find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
-                           uint length, Item **ref, bool register_tree_change,
+find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name, size_t length, Item **ref, bool register_tree_change,
                            TABLE_LIST **actual_table)
 {
   List_iterator_fast<Natural_join_column>
@@ -5626,7 +5625,7 @@ find_field_in_natural_join(THD *thd, TABLE_LIST *table_ref, const char *name,
 */
 
 Field *
-find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
+find_field_in_table(THD *thd, TABLE *table, const char *name, size_t length,
                     bool allow_rowid, uint *cached_field_index_ptr)
 {
   Field **field_ptr, *field;
@@ -5734,7 +5733,7 @@ find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
 
 Field *
 find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
-                        const char *name, uint length,
+                        const char *name, size_t length,
                         const char *item_name, const char *db_name,
                         const char *table_name, Item **ref,
                         bool check_privileges, bool allow_rowid,
@@ -5987,7 +5986,7 @@ find_field_in_tables(THD *thd, Item_ident *item,
   const char *db= item->db_name;
   const char *table_name= item->table_name;
   const char *name= item->field_name.str;
-  uint length= item->field_name.length;
+  size_t length= item->field_name.length;
   char name_buff[SAFE_NAME_LEN+1];
   TABLE_LIST *cur_table= first_table;
   TABLE_LIST *actual_table;
@@ -8530,8 +8529,8 @@ my_bool mysql_rm_tmp_tables(void)
                   tmp_file_prefix_length))
       {
         char *ext= fn_ext(file->name);
-        uint ext_len= strlen(ext);
-        uint filePath_len= my_snprintf(filePath, sizeof(filePath),
+        size_t ext_len= strlen(ext);
+        size_t filePath_len= my_snprintf(filePath, sizeof(filePath),
                                        "%s%c%s", tmpdir, FN_LIBCHAR,
                                        file->name);
         if (!strcmp(reg_ext, ext))
diff --git a/sql/sql_base.h b/sql/sql_base.h
index f2411c8b7ea..014eee56960 100644
--- a/sql/sql_base.h
+++ b/sql/sql_base.h
@@ -175,14 +175,14 @@ find_field_in_tables(THD *thd, Item_ident *item,
                      bool check_privileges, bool register_tree_change);
 Field *
 find_field_in_table_ref(THD *thd, TABLE_LIST *table_list,
-                        const char *name, uint length,
+                        const char *name, size_t length,
                         const char *item_name, const char *db_name,
                         const char *table_name, Item **ref,
                         bool check_privileges, bool allow_rowid,
                         uint *cached_field_index_ptr,
                         bool register_tree_change, TABLE_LIST **actual_table);
 Field *
-find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
+find_field_in_table(THD *thd, TABLE *table, const char *name, size_t length,
                     bool allow_rowid, uint *cached_field_index_ptr);
 Field *
 find_field_in_table_sef(TABLE *table, const char *name);
diff --git a/sql/sql_binlog.cc b/sql/sql_binlog.cc
index aa1a1cd6941..00270fb6f32 100644
--- a/sql/sql_binlog.cc
+++ b/sql/sql_binlog.cc
@@ -140,7 +140,7 @@ void mysql_client_binlog_statement(THD* thd)
     my_error(ER_SYNTAX_ERROR, MYF(0));
     DBUG_VOID_RETURN;
   }
-  size_t decoded_len= my_base64_needed_decoded_length(coded_len);
+  size_t decoded_len= my_base64_needed_decoded_length((int)coded_len);
 
   /*
     option_bits will be changed when applying the event. But we don't expect
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index c340f4afc8b..968cd9970f5 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -817,10 +817,10 @@ inline Query_cache_block * Query_cache_block_table::block()
    Query_cache_block method(s)
 *****************************************************************************/
 
-void Query_cache_block::init(ulong block_length)
+void Query_cache_block::init(size_t block_length)
 {
   DBUG_ENTER("Query_cache_block::init");
-  DBUG_PRINT("qcache", ("init block: %p  length: %lu", this,
+  DBUG_PRINT("qcache", ("init block: %p  length: %zu", this,
 			block_length));
   length = block_length;
   used = 0;
@@ -1037,7 +1037,7 @@ uchar *query_cache_query_get_key(const uchar *record, size_t *length,
 /**
   libmysql convenience wrapper to insert data into query cache.
 */
-void query_cache_insert(void *thd_arg, const char *packet, ulong length,
+void query_cache_insert(void *thd_arg, const char *packet, size_t length,
                         unsigned pkt_nr)
 {
   THD *thd= (THD*) thd_arg;
@@ -1053,7 +1053,7 @@ void query_cache_insert(void *thd_arg, const char *packet, ulong length,
     return;
 
   query_cache.insert(thd, &thd->query_cache_tls,
-                     packet, length,
+                     packet, (size_t)length,
                      pkt_nr);
 }
 
@@ -1064,7 +1064,7 @@ void query_cache_insert(void *thd_arg, const char *packet, ulong length,
 
 void
 Query_cache::insert(THD *thd, Query_cache_tls *query_cache_tls,
-                    const char *packet, ulong length,
+                    const char *packet, size_t length,
                     unsigned pkt_nr)
 {
   DBUG_ENTER("Query_cache::insert");
@@ -1097,7 +1097,7 @@ Query_cache::insert(THD *thd, Query_cache_tls *query_cache_tls,
   Query_cache_block *result= header->result();
 
   DUMP(this);
-  DBUG_PRINT("qcache", ("insert packet %lu bytes long",length));
+  DBUG_PRINT("qcache", ("insert packet %zu bytes long",length));
 
   /*
     On success, STRUCT_UNLOCK is done by append_result_data. Otherwise, we
@@ -1202,8 +1202,8 @@ void Query_cache::end_of_result(THD *thd)
     BLOCK_LOCK_WR(query_block);
     Query_cache_query *header= query_block->query();
     Query_cache_block *last_result_block;
-    ulong allign_size;
-    ulong len;
+    size_t allign_size;
+    size_t len;
 
     if (header->result() == 0)
     {
@@ -1263,9 +1263,9 @@ void mysql_query_cache_invalidate4(THD *thd,
    Query_cache methods
 *****************************************************************************/
 
-Query_cache::Query_cache(ulong query_cache_limit_arg,
-			 ulong min_allocation_unit_arg,
-			 ulong min_result_data_size_arg,
+Query_cache::Query_cache(size_t query_cache_limit_arg,
+			 size_t min_allocation_unit_arg,
+			 size_t min_result_data_size_arg,
 			 uint def_query_hash_size_arg,
 			 uint def_table_hash_size_arg)
   :query_cache_size(0),
@@ -1279,7 +1279,7 @@ Query_cache::Query_cache(ulong query_cache_limit_arg,
    def_table_hash_size(ALIGN_SIZE(def_table_hash_size_arg)),
    initialized(0)
 {
-  ulong min_needed= (ALIGN_SIZE(sizeof(Query_cache_block)) +
+  size_t min_needed= (ALIGN_SIZE(sizeof(Query_cache_block)) +
 		     ALIGN_SIZE(sizeof(Query_cache_block_table)) +
 		     ALIGN_SIZE(sizeof(Query_cache_query)) + 3);
   set_if_bigger(min_allocation_unit,min_needed);
@@ -1288,11 +1288,11 @@ Query_cache::Query_cache(ulong query_cache_limit_arg,
 }
 
 
-ulong Query_cache::resize(ulong query_cache_size_arg)
+size_t Query_cache::resize(size_t query_cache_size_arg)
 {
-  ulong new_query_cache_size;
+  size_t new_query_cache_size;
   DBUG_ENTER("Query_cache::resize");
-  DBUG_PRINT("qcache", ("from %lu to %lu",query_cache_size,
+  DBUG_PRINT("qcache", ("from %zu to %zu",query_cache_size,
 			query_cache_size_arg));
   DBUG_ASSERT(initialized);
 
@@ -1346,7 +1346,7 @@ ulong Query_cache::resize(ulong query_cache_size_arg)
 }
 
 
-ulong Query_cache::set_min_res_unit(ulong size)
+size_t Query_cache::set_min_res_unit(size_t size)
 {
   DBUG_ASSERT(size % 8 == 0);
   if (size < min_allocation_unit)
@@ -1358,7 +1358,7 @@ ulong Query_cache::set_min_res_unit(ulong size)
 void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used)
 {
   TABLE_COUNTER_TYPE local_tables;
-  ulong tot_length;
+  size_t tot_length;
   const char *query;
   size_t query_length;
   uint8 tables_type;
@@ -1446,8 +1446,8 @@ void Query_cache::store_query(THD *thd, TABLE_LIST *tables_used)
     DBUG_PRINT("qcache", ("\
 long %d, 4.1: %d, eof: %d, bin_proto: %d, more results %d, pkt_nr: %d, \
 CS client: %u, CS result: %u, CS conn: %u, limit: %llu, TZ: %p, \
-sql mode: 0x%llx, sort len: %llu, conncat len: %llu, div_precision: %lu, \
-def_week_frmt: %lu, in_trans: %d, autocommit: %d",
+sql mode: 0x%llx, sort len: %llu, conncat len: %llu, div_precision: %zu, \
+def_week_frmt: %zu, in_trans: %d, autocommit: %d",
                           (int)flags.client_long_flag,
                           (int)flags.client_protocol_41,
                           (int)flags.client_depr_eof,
@@ -1531,7 +1531,7 @@ def_week_frmt: %lu, in_trans: %d, autocommit: %d",
 				    Query_cache_block::QUERY, local_tables);
       if (query_block != 0)
       {
-	DBUG_PRINT("qcache", ("query block %p allocated, %lu",
+	DBUG_PRINT("qcache", ("query block %p allocated, %zu",
 			    query_block, query_block->used));
 
 	Query_cache_query *header = query_block->query();
@@ -1609,7 +1609,7 @@ end:
     @retval TRUE On error
 */
 static bool
-send_data_in_chunks(NET *net, const uchar *packet, ulong len)
+send_data_in_chunks(NET *net, const uchar *packet, size_t len)
 {
   /*
     On the client we may require more memory than max_allowed_packet
@@ -1625,7 +1625,7 @@ send_data_in_chunks(NET *net, const uchar *packet, ulong len)
     for max_allowed_packet, but large enough to ensure there is no
     unnecessary overhead from too many syscalls per result set.
   */
-  static const ulong MAX_CHUNK_LENGTH= 1024*1024;
+  static const size_t MAX_CHUNK_LENGTH= 1024*1024;
 
   while (len > MAX_CHUNK_LENGTH)
   {
@@ -1706,7 +1706,7 @@ Query_cache::send_result_to_client(THD *thd, char *org_sql, uint query_length)
 #endif
   Query_cache_block *result_block;
   Query_cache_block_table *block_table, *block_table_end;
-  ulong tot_length;
+  size_t tot_length;
   Query_cache_query_flags flags;
   const char *sql, *sql_end, *found_brace= 0;
   DBUG_ENTER("Query_cache::send_result_to_client");
@@ -1944,8 +1944,8 @@ Query_cache::send_result_to_client(THD *thd, char *org_sql, uint query_length)
   DBUG_PRINT("qcache", ("\
 long %d, 4.1: %d, eof: %d, bin_proto: %d, more results %d, pkt_nr: %d, \
 CS client: %u, CS result: %u, CS conn: %u, limit: %llu, TZ: %p, \
-sql mode: 0x%llx, sort len: %llu, conncat len: %llu, div_precision: %lu, \
-def_week_frmt: %lu, in_trans: %d, autocommit: %d",
+sql mode: 0x%llx, sort len: %llu, conncat len: %llu, div_precision: %zu, \
+def_week_frmt: %zu, in_trans: %d, autocommit: %d",
                           (int)flags.client_long_flag,
                           (int)flags.client_protocol_41,
                           (int)flags.client_depr_eof,
@@ -2092,7 +2092,7 @@ lookup:
     if (table->callback()) 
     {
       char qcache_se_key_name[FN_REFLEN + 10];
-      uint qcache_se_key_len, db_length= strlen(table->db());
+      size_t qcache_se_key_len, db_length= strlen(table->db());
       engine_data= table->engine_data();
 
       qcache_se_key_len= build_normalized_name(qcache_se_key_name,
@@ -2106,16 +2106,16 @@ lookup:
                                                table->suffix_length());
    
       if (!(*table->callback())(thd, qcache_se_key_name,
-                                qcache_se_key_len, &engine_data))
+                                (uint)qcache_se_key_len, &engine_data))
       {
         DBUG_PRINT("qcache", ("Handler does not allow caching for %.*s",
-                              qcache_se_key_len, qcache_se_key_name));
+                              (int)qcache_se_key_len, qcache_se_key_name));
         BLOCK_UNLOCK_RD(query_block);
         if (engine_data != table->engine_data())
         {
           DBUG_PRINT("qcache",
                      ("Handler require invalidation queries of %.*s %llu-%llu",
-                      qcache_se_key_len, qcache_se_key_name,
+                      (int)qcache_se_key_len, qcache_se_key_name,
                       engine_data, table->engine_data()));
           invalidate_table_internal(thd,
                                     (uchar *) table->db(),
@@ -2155,7 +2155,7 @@ lookup:
   THD_STAGE_INFO(thd, stage_sending_cached_result_to_client);
   do
   {
-    DBUG_PRINT("qcache", ("Results  (len: %lu  used: %lu  headers: %u)",
+    DBUG_PRINT("qcache", ("Results  (len: %zu  used: %zu  headers: %u)",
 			  result_block->length, result_block->used,
 			  (uint) (result_block->headers_len()+
                                    ALIGN_SIZE(sizeof(Query_cache_result)))));
@@ -2317,7 +2317,7 @@ void Query_cache::invalidate(THD *thd, TABLE *table,
   DBUG_VOID_RETURN;
 }
 
-void Query_cache::invalidate(THD *thd, const char *key, uint32  key_length,
+void Query_cache::invalidate(THD *thd, const char *key, size_t  key_length,
 			     my_bool using_transactions)
 {
   DBUG_ENTER("Query_cache::invalidate (key)");
@@ -2461,7 +2461,7 @@ void Query_cache::flush()
 
 */
 
-void Query_cache::pack(THD *thd, ulong join_limit, uint iteration_limit)
+void Query_cache::pack(THD *thd, size_t join_limit, uint iteration_limit)
 {
   DBUG_ENTER("Query_cache::pack");
 
@@ -2580,11 +2580,11 @@ void Query_cache::init()
 }
 
 
-ulong Query_cache::init_cache()
+size_t Query_cache::init_cache()
 {
-  uint mem_bin_count, num, step;
-  ulong mem_bin_size, prev_size, inc;
-  ulong additional_data_size, max_mem_bin_size, approx_additional_data_size;
+  size_t mem_bin_count, num, step;
+  size_t mem_bin_size, prev_size, inc;
+  size_t additional_data_size, max_mem_bin_size, approx_additional_data_size;
   int align;
 
   DBUG_ENTER("Query_cache::init_cache");
@@ -2650,7 +2650,7 @@ ulong Query_cache::init_cache()
         my_malloc_lock(query_cache_size+additional_data_size, MYF(0))))
     goto err;
 
-  DBUG_PRINT("qcache", ("cache length %lu, min unit %lu, %u bins",
+  DBUG_PRINT("qcache", ("cache length %zu, min unit %zu, %zu bins",
 		      query_cache_size, min_allocation_unit, mem_bin_num));
 
   steps = (Query_cache_memory_bin_step *) cache;
@@ -2674,9 +2674,9 @@ ulong Query_cache::init_cache()
   mem_bin_size = max_mem_bin_size >> QUERY_CACHE_MEM_BIN_STEP_PWR2;
   while (mem_bin_size > min_allocation_unit)
   {
-    ulong incr = (steps[step-1].size - mem_bin_size) / mem_bin_count;
-    unsigned long size = mem_bin_size;
-    for (uint i= mem_bin_count; i > 0; i--)
+    size_t incr = (steps[step-1].size - mem_bin_size) / mem_bin_count;
+    size_t size = mem_bin_size;
+    for (size_t i= mem_bin_count; i > 0; i--)
     {
       bins[num+i-1].init(size);
       size += incr;
@@ -2699,9 +2699,9 @@ ulong Query_cache::init_cache()
 
   steps[step].init(mem_bin_size, num + mem_bin_count - 1, inc);
   {
-    uint skiped = (min_allocation_unit - mem_bin_size)/inc;
-    ulong size = mem_bin_size + inc*skiped;
-    uint i = mem_bin_count - skiped;
+    size_t skiped = (min_allocation_unit - mem_bin_size)/inc;
+    size_t size = mem_bin_size + inc*skiped;
+    size_t i = mem_bin_count - skiped;
     while (i-- > 0)
     {
       bins[num+i].init(size);
@@ -2902,7 +2902,7 @@ my_bool Query_cache::free_old_query()
 void Query_cache::free_query_internal(Query_cache_block *query_block)
 {
   DBUG_ENTER("Query_cache::free_query_internal");
-  DBUG_PRINT("qcache", ("free query %p %lu bytes result",
+  DBUG_PRINT("qcache", ("free query %p %zu bytes result",
 		      query_block,
 		      query_block->query()->length() ));
 
@@ -2972,7 +2972,7 @@ void Query_cache::free_query_internal(Query_cache_block *query_block)
 void Query_cache::free_query(Query_cache_block *query_block)
 {
   DBUG_ENTER("Query_cache::free_query");
-  DBUG_PRINT("qcache", ("free query %p %lu bytes result",
+  DBUG_PRINT("qcache", ("free query %p %zu bytes result",
 		      query_block,
 		      query_block->query()->length() ));
 
@@ -2987,18 +2987,18 @@ void Query_cache::free_query(Query_cache_block *query_block)
 *****************************************************************************/
 
 Query_cache_block *
-Query_cache::write_block_data(ulong data_len, uchar* data,
-			      ulong header_len,
+Query_cache::write_block_data(size_t data_len, uchar* data,
+			      size_t header_len,
 			      Query_cache_block::block_type type,
 			      TABLE_COUNTER_TYPE ntab)
 {
-  ulong all_headers_len = (ALIGN_SIZE(sizeof(Query_cache_block)) +
+  size_t all_headers_len = (ALIGN_SIZE(sizeof(Query_cache_block)) +
 			   ALIGN_SIZE(ntab*sizeof(Query_cache_block_table)) +
 			   header_len);
-  ulong len = data_len + all_headers_len;
-  ulong align_len= ALIGN_SIZE(len);
+  size_t len = data_len + all_headers_len;
+  size_t align_len= ALIGN_SIZE(len);
   DBUG_ENTER("Query_cache::write_block_data");
-  DBUG_PRINT("qcache", ("data: %ld, header: %ld, all header: %ld",
+  DBUG_PRINT("qcache", ("data: %zd, header: %zd, all header: %zd",
 		      data_len, header_len, all_headers_len));
   Query_cache_block *block= allocate_block(MY_MAX(align_len,
                                            min_allocation_unit),1, 0);
@@ -3016,33 +3016,33 @@ Query_cache::write_block_data(ulong data_len, uchar* data,
 
 my_bool
 Query_cache::append_result_data(Query_cache_block **current_block,
-				ulong data_len, uchar* data,
+				size_t data_len, uchar* data,
 				Query_cache_block *query_block)
 {
   DBUG_ENTER("Query_cache::append_result_data");
-  DBUG_PRINT("qcache", ("append %lu bytes to %p query",
+  DBUG_PRINT("qcache", ("append %zu bytes to %p query",
 		      data_len, query_block));
 
   if (query_block->query()->add(data_len) > query_cache_limit)
   {
-    DBUG_PRINT("qcache", ("size limit reached %lu > %lu",
+    DBUG_PRINT("qcache", ("size limit reached %zu > %zu",
 			query_block->query()->length(),
 			query_cache_limit));
     DBUG_RETURN(0);
   }
   if (*current_block == 0)
   {
-    DBUG_PRINT("qcache", ("allocated first result data block %lu", data_len));
+    DBUG_PRINT("qcache", ("allocated first result data block %zu", data_len));
     DBUG_RETURN(write_result_data(current_block, data_len, data, query_block,
 				  Query_cache_block::RES_BEG));
   }
   Query_cache_block *last_block = (*current_block)->prev;
 
-  DBUG_PRINT("qcache", ("lastblock %p len %lu used %lu",
+  DBUG_PRINT("qcache", ("lastblock %p len %zu used %zu",
 		      last_block, last_block->length,
 		      last_block->used));
   my_bool success = 1;
-  ulong last_block_free_space= last_block->length - last_block->used;
+  size_t last_block_free_space= last_block->length - last_block->used;
 
   /*
     We will first allocate and write the 'tail' of data, that doesn't fit
@@ -3051,8 +3051,8 @@ Query_cache::append_result_data(Query_cache_block **current_block,
   */
 
   // Try join blocks if physically next block is free...
-  ulong tail = data_len - last_block_free_space;
-  ulong append_min = get_min_append_result_data_size();
+  size_t tail = data_len - last_block_free_space;
+  size_t append_min = get_min_append_result_data_size();
   if (last_block_free_space < data_len &&
       append_next_free_block(last_block,
 			     MY_MAX(tail, append_min)))
@@ -3060,7 +3060,7 @@ Query_cache::append_result_data(Query_cache_block **current_block,
   // If no space in last block (even after join) allocate new block
   if (last_block_free_space < data_len)
   {
-    DBUG_PRINT("qcache", ("allocate new block for %lu bytes",
+    DBUG_PRINT("qcache", ("allocate new block for %zu bytes",
 			data_len-last_block_free_space));
     Query_cache_block *new_block = 0;
     success = write_result_data(&new_block, data_len-last_block_free_space,
@@ -3083,8 +3083,8 @@ Query_cache::append_result_data(Query_cache_block **current_block,
   // Now finally write data to the last block
   if (success && last_block_free_space > 0)
   {
-    ulong to_copy = MY_MIN(data_len,last_block_free_space);
-    DBUG_PRINT("qcache", ("use free space %lub at block %p to copy %lub",
+    size_t to_copy = MY_MIN(data_len,last_block_free_space);
+    DBUG_PRINT("qcache", ("use free space %zub at block %p to copy %zub",
 			last_block_free_space,last_block, to_copy));
     memcpy((uchar*) last_block + last_block->used, data, to_copy);
     last_block->used+=to_copy;
@@ -3094,12 +3094,12 @@ Query_cache::append_result_data(Query_cache_block **current_block,
 
 
 my_bool Query_cache::write_result_data(Query_cache_block **result_block,
-				       ulong data_len, uchar* data,
+				       size_t data_len, uchar* data,
 				       Query_cache_block *query_block,
 				       Query_cache_block::block_type type)
 {
   DBUG_ENTER("Query_cache::write_result_data");
-  DBUG_PRINT("qcache", ("data_len %lu",data_len));
+  DBUG_PRINT("qcache", ("data_len %zu",data_len));
 
   /*
     Reserve block(s) for filling
@@ -3125,8 +3125,8 @@ my_bool Query_cache::write_result_data(Query_cache_block **result_block,
     do
     {
       block->type = type;
-      ulong length = block->used - headers_len;
-      DBUG_PRINT("qcache", ("write %lu byte in block %p",length,
+      size_t length = block->used - headers_len;
+      DBUG_PRINT("qcache", ("write %zu byte in block %p",length,
 			   block));
       memcpy((uchar*) block+headers_len, rest, length);
       rest += length;
@@ -3166,16 +3166,16 @@ my_bool Query_cache::write_result_data(Query_cache_block **result_block,
   DBUG_RETURN(success);
 }
 
-inline ulong Query_cache::get_min_first_result_data_size()
+inline size_t Query_cache::get_min_first_result_data_size()
 {
   if (queries_in_cache < QUERY_CACHE_MIN_ESTIMATED_QUERIES_NUMBER)
     return min_result_data_size;
-  ulong avg_result = (query_cache_size - free_memory) / queries_in_cache;
+  size_t avg_result = (query_cache_size - free_memory) / queries_in_cache;
   avg_result = MY_MIN(avg_result, query_cache_limit);
   return MY_MAX(min_result_data_size, avg_result);
 }
 
-inline ulong Query_cache::get_min_append_result_data_size()
+inline size_t Query_cache::get_min_append_result_data_size()
 {
   return min_result_data_size;
 }
@@ -3184,25 +3184,25 @@ inline ulong Query_cache::get_min_append_result_data_size()
   Allocate one or more blocks to hold data
 */
 my_bool Query_cache::allocate_data_chain(Query_cache_block **result_block,
-					 ulong data_len,
+					 size_t data_len,
 					 Query_cache_block *query_block,
 					 my_bool first_block_arg)
 {
-  ulong all_headers_len = (ALIGN_SIZE(sizeof(Query_cache_block)) +
+  size_t all_headers_len = (ALIGN_SIZE(sizeof(Query_cache_block)) +
 			   ALIGN_SIZE(sizeof(Query_cache_result)));
-  ulong min_size = (first_block_arg ?
+  size_t min_size = (first_block_arg ?
 		    get_min_first_result_data_size():
 		    get_min_append_result_data_size());
   Query_cache_block *prev_block= NULL;
   Query_cache_block *new_block;
   DBUG_ENTER("Query_cache::allocate_data_chain");
-  DBUG_PRINT("qcache", ("data_len %lu, all_headers_len %lu",
+  DBUG_PRINT("qcache", ("data_len %zu, all_headers_len %zu",
 			data_len, all_headers_len));
 
   do
   {
-    ulong len= data_len + all_headers_len;
-    ulong align_len= ALIGN_SIZE(len);
+    size_t len= data_len + all_headers_len;
+    size_t align_len= ALIGN_SIZE(len);
 
     if (!(new_block= allocate_block(MY_MAX(min_size, align_len),
 				    min_result_data_size == 0,
@@ -3219,7 +3219,7 @@ my_bool Query_cache::allocate_data_chain(Query_cache_block **result_block,
     Query_cache_result *header = new_block->result();
     header->parent(query_block);
 
-    DBUG_PRINT("qcache", ("Block len %lu used %lu",
+    DBUG_PRINT("qcache", ("Block len %zu used %zu",
 			  new_block->length, new_block->used));
 
     if (prev_block)
@@ -3269,7 +3269,7 @@ void Query_cache::invalidate_table(THD *thd, TABLE *table)
                    table->s->table_cache_key.length);
 }
 
-void Query_cache::invalidate_table(THD *thd, uchar * key, uint32  key_length)
+void Query_cache::invalidate_table(THD *thd, uchar * key, size_t key_length)
 {
   DEBUG_SYNC(thd, "wait_in_query_cache_invalidate1");
 
@@ -3297,7 +3297,7 @@ void Query_cache::invalidate_table(THD *thd, uchar * key, uint32  key_length)
 */
 
 void
-Query_cache::invalidate_table_internal(THD *thd, uchar *key, uint32 key_length)
+Query_cache::invalidate_table_internal(THD *thd, uchar *key, size_t key_length)
 {
   Query_cache_block *table_block=
     (Query_cache_block*)my_hash_search(&tables, key, key_length);
@@ -3463,16 +3463,15 @@ my_bool Query_cache::register_all_tables(THD *thd,
 */
 
 my_bool
-Query_cache::insert_table(THD *thd, uint key_len, const char *key,
-			  Query_cache_block_table *node,
-			  uint32 db_length, uint8 suffix_length_arg,
+Query_cache::insert_table(THD *thd, size_t key_len, const char *key,
+			  Query_cache_block_table *node, size_t db_length, uint8 suffix_length_arg,
                           uint8 cache_type,
                           qc_engine_callback callback,
                           ulonglong engine_data,
                           my_bool hash)
 {
   DBUG_ENTER("Query_cache::insert_table");
-  DBUG_PRINT("qcache", ("insert table node %p, len %d",
+  DBUG_PRINT("qcache", ("insert table node %p, len %zu",
 		     node, key_len));
 
   Query_cache_block *table_block=
@@ -3538,7 +3537,7 @@ Query_cache::insert_table(THD *thd, uint key_len, const char *key,
     }
     char *db= header->db();
     header->table(db + db_length + 1);
-    header->key_length(key_len);
+    header->key_length((uint32)key_len);
     header->suffix_length(suffix_length_arg);
     header->type(cache_type);
     header->callback(callback);
@@ -3610,15 +3609,15 @@ void Query_cache::unlink_table(Query_cache_block_table *node)
 *****************************************************************************/
 
 Query_cache_block *
-Query_cache::allocate_block(ulong len, my_bool not_less, ulong min)
+Query_cache::allocate_block(size_t len, my_bool not_less, size_t min)
 {
   DBUG_ENTER("Query_cache::allocate_block");
-  DBUG_PRINT("qcache", ("len %lu, not less %d, min %lu",
+  DBUG_PRINT("qcache", ("len %zu, not less %d, min %zu",
              len, not_less,min));
 
   if (len >= MY_MIN(query_cache_size, query_cache_limit))
   {
-    DBUG_PRINT("qcache", ("Query cache hase only %lu memory and limit %lu",
+    DBUG_PRINT("qcache", ("Query cache hase only %zu memory and limit %zu",
 			query_cache_size, query_cache_limit));
     DBUG_RETURN(0); // in any case we don't have such piece of memory
   }
@@ -3642,11 +3641,11 @@ Query_cache::allocate_block(ulong len, my_bool not_less, ulong min)
 
 
 Query_cache_block *
-Query_cache::get_free_block(ulong len, my_bool not_less, ulong min)
+Query_cache::get_free_block(size_t len, my_bool not_less, size_t min)
 {
   Query_cache_block *block = 0, *first = 0;
   DBUG_ENTER("Query_cache::get_free_block");
-  DBUG_PRINT("qcache",("length %lu, not_less %d, min %lu", len,
+  DBUG_PRINT("qcache",("length %zu, not_less %d, min %zu", len,
 		     (int)not_less, min));
 
   /* Find block with minimal size > len  */
@@ -3737,7 +3736,7 @@ void Query_cache::free_memory_block(Query_cache_block *block)
 }
 
 
-void Query_cache::split_block(Query_cache_block *block, ulong len)
+void Query_cache::split_block(Query_cache_block *block, size_t len)
 {
   DBUG_ENTER("Query_cache::split_block");
   Query_cache_block *new_block = (Query_cache_block*)(((uchar*) block)+len);
@@ -3758,7 +3757,7 @@ void Query_cache::split_block(Query_cache_block *block, ulong len)
   else
     free_memory_block(new_block);
 
-  DBUG_PRINT("qcache", ("split %p (%lu) new %p",
+  DBUG_PRINT("qcache", ("split %p (%zu) new %p",
 		      block, len, new_block));
   DBUG_VOID_RETURN;
 }
@@ -3791,16 +3790,16 @@ Query_cache::join_free_blocks(Query_cache_block *first_block_arg,
 
 
 my_bool Query_cache::append_next_free_block(Query_cache_block *block,
-					    ulong add_size)
+					    size_t add_size)
 {
   Query_cache_block *next_block = block->pnext;
   DBUG_ENTER("Query_cache::append_next_free_block");
-  DBUG_PRINT("enter", ("block %p, add_size %lu", block,
+  DBUG_PRINT("enter", ("block %p, add_size %zu", block,
 		       add_size));
 
   if (next_block != first_block && next_block->is_free())
   {
-    ulong old_len = block->length;
+    size_t old_len = block->length;
     exclude_from_free_memory_list(next_block);
     next_block->destroy();
     total_blocks--;
@@ -3850,14 +3849,14 @@ void Query_cache::insert_into_free_memory_list(Query_cache_block *free_block)
   DBUG_VOID_RETURN;
 }
 
-uint Query_cache::find_bin(ulong size)
+uint Query_cache::find_bin(size_t size)
 {
   DBUG_ENTER("Query_cache::find_bin");
   // Binary search
-  int left = 0, right = mem_bin_steps;
+  size_t left = 0, right = mem_bin_steps;
   do
   {
-    int middle = (left + right) / 2;
+    size_t middle = (left + right) / 2;
     if (steps[middle].size > size)
       left = middle+1;
     else
@@ -3866,15 +3865,15 @@ uint Query_cache::find_bin(ulong size)
   if (left == 0)
   {
     // first bin not subordinate of common rules
-    DBUG_PRINT("qcache", ("first bin (# 0), size %lu",size));
+    DBUG_PRINT("qcache", ("first bin (# 0), size %zu",size));
     DBUG_RETURN(0);
   }
-  uint bin =  steps[left].idx - 
-    (uint)((size - steps[left].size)/steps[left].increment);
+  size_t bin =  steps[left].idx - 
+    ((size - steps[left].size)/steps[left].increment);
 
-  DBUG_PRINT("qcache", ("bin %u step %u, size %lu step size %lu",
+  DBUG_PRINT("qcache", ("bin %zu step %zu, size %zu step size %zu",
 			bin, left, size, steps[left].size));
-  DBUG_RETURN(bin);
+  DBUG_RETURN((uint)bin);
 }
 
 
@@ -4172,7 +4171,7 @@ my_bool Query_cache::ask_handler_allowance(THD *thd,
     handler= table->file;
     if (!handler->register_query_cache_table(thd,
                                              table->s->normalized_path.str,
-                                             table->s->normalized_path.length,
+                                             (uint)table->s->normalized_path.length,
 					     &tables_used->callback_func,
 					     &tables_used->engine_data))
     {
@@ -4198,7 +4197,7 @@ my_bool Query_cache::ask_handler_allowance(THD *thd,
 /**
   Rearrange all memory blocks so that free memory joins at the
   'bottom' of the allocated memory block containing all cache data.
-  @see Query_cache::pack(ulong join_limit, uint iteration_limit)
+  @see Query_cache::pack(size_t join_limit, uint iteration_limit)
 */
 
 void Query_cache::pack_cache()
@@ -4209,7 +4208,7 @@ void Query_cache::pack_cache()
 
   uchar *border = 0;
   Query_cache_block *before = 0;
-  ulong gap = 0;
+  size_t gap = 0;
   my_bool ok = 1;
   Query_cache_block *block = first_block;
   DUMP(this);
@@ -4243,7 +4242,7 @@ void Query_cache::pack_cache()
 
 
 my_bool Query_cache::move_by_type(uchar **border,
-				  Query_cache_block **before, ulong *gap,
+				  Query_cache_block **before, size_t *gap,
 				  Query_cache_block *block)
 {
   DBUG_ENTER("Query_cache::move_by_type");
@@ -4265,7 +4264,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     block->pnext->pprev=block->pprev;
     block->destroy();
     total_blocks--;
-    DBUG_PRINT("qcache", ("added to gap (%lu)", *gap));
+    DBUG_PRINT("qcache", ("added to gap (%zu)", *gap));
     break;
   }
   case Query_cache_block::TABLE:
@@ -4274,7 +4273,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     DBUG_PRINT("qcache", ("block %p TABLE", block));
     if (*border == 0)
       break;
-    ulong len = block->length, used = block->used;
+    size_t len = block->length, used = block->used;
     Query_cache_block_table *list_root = block->table(0);
     Query_cache_block_table *tprev = list_root->prev,
 			    *tnext = list_root->next;
@@ -4324,7 +4323,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     /* Fix hash to point at moved block */
     my_hash_replace(&tables, &record_idx, (uchar*) new_block);
 
-    DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p",
+    DBUG_PRINT("qcache", ("moved %zu bytes to %p, new gap at %p",
 			len, new_block, *border));
     break;
   }
@@ -4335,7 +4334,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     if (*border == 0)
       break;
     BLOCK_LOCK_WR(block);
-    ulong len = block->length, used = block->used;
+    size_t len = block->length, used = block->used;
     TABLE_COUNTER_TYPE n_tables = block->n_tables;
     Query_cache_block	*prev = block->prev,
 			*next = block->next,
@@ -4417,7 +4416,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     }
     /* Fix hash to point at moved block */
     my_hash_replace(&queries, &record_idx, (uchar*) new_block);
-    DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p",
+    DBUG_PRINT("qcache", ("moved %zu bytes to %p, new gap at %p",
 			len, new_block, *border));
     break;
   }
@@ -4434,7 +4433,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     BLOCK_LOCK_WR(query_block);
     Query_cache_block *next= block->next, *prev= block->prev;
     Query_cache_block::block_type type= block->type;
-    ulong len = block->length, used = block->used;
+    size_t len = block->length, used = block->used;
     Query_cache_block *pprev = block->pprev,
 		      *pnext = block->pnext,
 		      *new_block =(Query_cache_block*) *border;
@@ -4452,7 +4451,7 @@ my_bool Query_cache::move_by_type(uchar **border,
     *border += len;
     *before = new_block;
     /* If result writing complete && we have free space in block */
-    ulong free_space= new_block->length - new_block->used;
+    size_t free_space= new_block->length - new_block->used;
     free_space-= free_space % ALIGN_SIZE(1);
     if (query->result()->type == Query_cache_block::RESULT &&
 	new_block->length > new_block->used &&
@@ -4462,11 +4461,11 @@ my_bool Query_cache::move_by_type(uchar **border,
       *border-= free_space;
       *gap+= free_space;
       DBUG_PRINT("qcache",
-		 ("rest of result free space added to gap (%lu)", *gap));
+		 ("rest of result free space added to gap (%zu)", *gap));
       new_block->length -= free_space;
     }
     BLOCK_UNLOCK_WR(query_block);
-    DBUG_PRINT("qcache", ("moved %lu bytes to %p, new gap at %p",
+    DBUG_PRINT("qcache", ("moved %zu bytes to %p, new gap at %p",
 			len, new_block, *border));
     break;
   }
@@ -4506,7 +4505,7 @@ void Query_cache::relink(Query_cache_block *oblock,
 }
 
 
-my_bool Query_cache::join_results(ulong join_limit)
+my_bool Query_cache::join_results(size_t join_limit)
 {
   my_bool has_moving = 0;
   DBUG_ENTER("Query_cache::join_results");
@@ -4530,7 +4529,7 @@ my_bool Query_cache::join_results(ulong join_limit)
 	{
 	  has_moving = 1;
 	  Query_cache_block *first_result = header->result();
-	  ulong new_len = (header->length() +
+	  size_t new_len = (header->length() +
 			   ALIGN_SIZE(sizeof(Query_cache_block)) +
 			   ALIGN_SIZE(sizeof(Query_cache_result)));
 	  if (new_result_block->length >
@@ -4543,7 +4542,7 @@ my_bool Query_cache::join_results(ulong join_limit)
 	  new_result_block->used = new_len;
 
 	  new_result_block->next = new_result_block->prev = new_result_block;
-	  DBUG_PRINT("qcache", ("new block %lu/%lu (%lu)",
+	  DBUG_PRINT("qcache", ("new block %zu/%zu (%zu)",
 			      new_result_block->length,
 			      new_result_block->used,
 			      header->length()));
@@ -4554,9 +4553,9 @@ my_bool Query_cache::join_results(ulong join_limit)
 	  Query_cache_block *result_block = first_result;
 	  do
 	  {
-	    ulong len = (result_block->used - result_block->headers_len() -
+	    size_t len = (result_block->used - result_block->headers_len() -
 			 ALIGN_SIZE(sizeof(Query_cache_result)));
-	    DBUG_PRINT("loop", ("add block %lu/%lu (%lu)",
+	    DBUG_PRINT("loop", ("add block %zu/%zu (%zu)",
 				result_block->length,
 				result_block->used,
 				len));
@@ -4658,14 +4657,14 @@ void Query_cache::bins_dump()
     return;
   }
 
-  DBUG_PRINT("qcache", ("mem_bin_num=%u, mem_bin_steps=%u",
+  DBUG_PRINT("qcache", ("mem_bin_num=%zu, mem_bin_steps=%zu",
 		      mem_bin_num, mem_bin_steps));
   DBUG_PRINT("qcache", ("-------------------------"));
   DBUG_PRINT("qcache", ("      size idx       step"));
   DBUG_PRINT("qcache", ("-------------------------"));
   for (i=0; i < mem_bin_steps; i++)
   {
-    DBUG_PRINT("qcache", ("%10lu %3d %10lu", steps[i].size, steps[i].idx,
+    DBUG_PRINT("qcache", ("%10zu %3zd %10zu", steps[i].size, steps[i].idx,
 			steps[i].increment));
   }
   DBUG_PRINT("qcache", ("-------------------------"));
@@ -4673,13 +4672,13 @@ void Query_cache::bins_dump()
   DBUG_PRINT("qcache", ("-------------------------"));
   for (i=0; i < mem_bin_num; i++)
   {
-    DBUG_PRINT("qcache", ("%10lu %3d %p", bins[i].size, bins[i].number,
+    DBUG_PRINT("qcache", ("%10zu %3d %p", bins[i].size, bins[i].number,
 			&(bins[i])));
     if (bins[i].free_blocks)
     {
       Query_cache_block *block = bins[i].free_blocks;
       do{
-	DBUG_PRINT("qcache", ("\\-- %lu %p %p %p %p %p",
+	DBUG_PRINT("qcache", ("\\-- %zu %p %p %p %p %p",
 			    block->length,block,
 			   block->next,block->prev,
 			   block->pnext,block->pprev));
@@ -4706,7 +4705,7 @@ void Query_cache::cache_dump()
   do
   {
     DBUG_PRINT("qcache",
-	       ("%10lu %10lu %1d %2d %p %p %p %p %p",
+	       ("%10zu %10zu %1d %2d %p %p %p %p %p",
 		i->length, i->used, (int)i->type,
 		i->n_tables,i,
 		i->next,i->prev,i->pnext,
@@ -4762,7 +4761,7 @@ void Query_cache::queries_dump()
 	Query_cache_block *result_beg = result_block;
 	do
 	{
-	  DBUG_PRINT("qcache", ("-r- %u %lu/%lu %p %p %p %p %p",
+	  DBUG_PRINT("qcache", ("-r- %u %zu/%zu %p %p %p %p %p",
 			      (uint) result_block->type,
 			      result_block->length, result_block->used,
 			      result_block,
@@ -4840,7 +4839,7 @@ my_bool Query_cache::check_integrity(bool locked)
   }
 
   DBUG_PRINT("qcache", ("physical address check ..."));
-  ulong free=0, used=0;
+  size_t free=0, used=0;
   Query_cache_block * block = first_block;
   do
   {
@@ -4905,7 +4904,7 @@ my_bool Query_cache::check_integrity(bool locked)
       }
       else
       {
-	int idx = (((uchar*)bin) - ((uchar*)bins)) /
+	size_t idx = (((uchar*)bin) - ((uchar*)bins)) /
 	  sizeof(Query_cache_memory_bin);
 	if (in_list(bins[idx].free_blocks, block, "free memory"))
 	  result = 1;
@@ -4978,7 +4977,7 @@ my_bool Query_cache::check_integrity(bool locked)
   if (used + free != query_cache_size)
   {
     DBUG_PRINT("error",
-	       ("used memory (%lu) + free memory (%lu) !=  query_cache_size (%lu)",
+	       ("used memory (%zu) + free memory (%zu) !=  query_cache_size (%zu)",
 		used, free, query_cache_size));
     result = 1;
   }
@@ -4986,7 +4985,7 @@ my_bool Query_cache::check_integrity(bool locked)
   if (free != free_memory)
   {
     DBUG_PRINT("error",
-	       ("free memory (%lu) != free_memory (%lu)",
+	       ("free memory (%zu) != free_memory (%zu)",
 		free, free_memory));
     result = 1;
   }
diff --git a/sql/sql_cache.h b/sql/sql_cache.h
index 6fc083ee331..eb046b4d167 100644
--- a/sql/sql_cache.h
+++ b/sql/sql_cache.h
@@ -126,8 +126,8 @@ struct Query_cache_block
   enum block_type {FREE, QUERY, RESULT, RES_CONT, RES_BEG,
 		   RES_INCOMPLETE, TABLE, INCOMPLETE};
 
-  ulong length;					// length of all block
-  ulong used;					// length of data
+  size_t length;					// length of all block
+  size_t used;					// length of data
   /*
     Not used **pprev, **prev because really needed access to pervious block:
     *pprev to join free blocks
@@ -139,7 +139,7 @@ struct Query_cache_block
   TABLE_COUNTER_TYPE n_tables;			// number of tables in query
 
   inline bool is_free(void) { return type == FREE; }
-  void init(ulong length);
+  void init(size_t length);
   void destroy();
   uint headers_len();
   uchar* data(void);
@@ -155,7 +155,7 @@ struct Query_cache_query
   mysql_rwlock_t lock;
   Query_cache_block *res;
   Query_cache_tls *wri;
-  ulong len;
+  size_t len;
   unsigned int last_pkt_nr;
   uint8 tbls_type;
   uint8 ready;
@@ -172,9 +172,9 @@ struct Query_cache_query
   inline void writer(Query_cache_tls *p)   { wri= p; }
   inline uint8 tables_type()               { return tbls_type; }
   inline void tables_type(uint8 type)      { tbls_type= type; }
-  inline ulong length()			   { return len; }
-  inline ulong add(ulong packet_len)	   { return(len+= packet_len); }
-  inline void length(ulong length_arg)	   { len= length_arg; }
+  inline size_t length()			   { return len; }
+  inline size_t add(size_t packet_len)	   { return(len+= packet_len); }
+  inline void length(size_t length_arg)	   { len= length_arg; }
   inline uchar* query()
   {
     return (((uchar*)this) + ALIGN_SIZE(sizeof(Query_cache_query)));
@@ -268,12 +268,12 @@ struct Query_cache_memory_bin
 {
   Query_cache_memory_bin() {}                 /* Remove gcc warning */
 #ifndef DBUG_OFF
-  ulong size;
+  size_t size;
 #endif
   uint number;
   Query_cache_block *free_blocks;
 
-  inline void init(ulong size_arg)
+  inline void init(size_t size_arg)
   {
 #ifndef DBUG_OFF
     size = size_arg;
@@ -286,10 +286,10 @@ struct Query_cache_memory_bin
 struct Query_cache_memory_bin_step
 {
   Query_cache_memory_bin_step() {}            /* Remove gcc warning */
-  ulong size;
-  ulong increment;
-  uint idx;
-  inline void init(ulong size_arg, uint idx_arg, ulong increment_arg)
+  size_t size;
+  size_t increment;
+  size_t idx;
+  inline void init(size_t size_arg, size_t idx_arg, size_t increment_arg)
   {
     size = size_arg;
     idx = idx_arg;
@@ -301,9 +301,9 @@ class Query_cache
 {
 public:
   /* Info */
-  ulong query_cache_size, query_cache_limit;
+  size_t query_cache_size, query_cache_limit;
   /* statistics */
-  ulong free_memory, queries_in_cache, hits, inserts, refused,
+  size_t free_memory, queries_in_cache, hits, inserts, refused,
     free_memory_blocks, total_blocks, lowmem_prunes;
 
 
@@ -319,7 +319,7 @@ private:
   Cache_staus m_cache_status;
 
   void free_query_internal(Query_cache_block *point);
-  void invalidate_table_internal(THD *thd, uchar *key, uint32 key_length);
+  void invalidate_table_internal(THD *thd, uchar *key, size_t key_length);
 
 protected:
   /*
@@ -346,10 +346,10 @@ protected:
   Query_cache_memory_bin_step *steps;		// bins spacing info
   HASH queries, tables;
   /* options */
-  ulong min_allocation_unit, min_result_data_size;
+  size_t min_allocation_unit, min_result_data_size;
   uint def_query_hash_size, def_table_hash_size;
   
-  uint mem_bin_num, mem_bin_steps;		// See at init_cache & find_bin
+  size_t mem_bin_num, mem_bin_steps;		// See at init_cache & find_bin
 
   bool initialized;
 
@@ -367,12 +367,12 @@ protected:
   my_bool free_old_query();
   void free_query(Query_cache_block *point);
   my_bool allocate_data_chain(Query_cache_block **result_block,
-			      ulong data_len,
+			      size_t data_len,
 			      Query_cache_block *query_block,
 			      my_bool first_block);
   void invalidate_table(THD *thd, TABLE_LIST *table);
   void invalidate_table(THD *thd, TABLE *table);
-  void invalidate_table(THD *thd, uchar *key, uint32  key_length);
+  void invalidate_table(THD *thd, uchar *key, size_t  key_length);
   void invalidate_table(THD *thd, Query_cache_block *table_block);
   void invalidate_query_block_list(THD *thd, 
                                    Query_cache_block_table *list_root);
@@ -385,19 +385,19 @@ protected:
 			      TABLE_LIST *tables_used,
 			      TABLE_COUNTER_TYPE tables);
   void unlink_table(Query_cache_block_table *node);
-  Query_cache_block *get_free_block (ulong len, my_bool not_less,
-				      ulong min);
+  Query_cache_block *get_free_block (size_t len, my_bool not_less,
+				      size_t min);
   void free_memory_block(Query_cache_block *point);
-  void split_block(Query_cache_block *block, ulong len);
+  void split_block(Query_cache_block *block, size_t len);
   Query_cache_block *join_free_blocks(Query_cache_block *first_block,
 				       Query_cache_block *block_in_list);
   my_bool append_next_free_block(Query_cache_block *block,
-				 ulong add_size);
+				 size_t add_size);
   void exclude_from_free_memory_list(Query_cache_block *free_block);
   void insert_into_free_memory_list(Query_cache_block *new_block);
   my_bool move_by_type(uchar **border, Query_cache_block **before,
-		       ulong *gap, Query_cache_block *i);
-  uint find_bin(ulong size);
+		       size_t *gap, Query_cache_block *i);
+  uint find_bin(size_t size);
   void move_to_query_list_end(Query_cache_block *block);
   void insert_into_free_memory_sorted_list(Query_cache_block *new_block,
 					   Query_cache_block **list);
@@ -408,31 +408,31 @@ protected:
 	      Query_cache_block *prev,
 	      Query_cache_block *pnext,
 	      Query_cache_block *pprev);
-  my_bool join_results(ulong join_limit);
+  my_bool join_results(size_t join_limit);
 
   /*
     Following function control structure_guard_mutex
     by themself or don't need structure_guard_mutex
   */
-  ulong init_cache();
+  size_t init_cache();
   void make_disabled();
   void free_cache();
-  Query_cache_block *write_block_data(ulong data_len, uchar* data,
-				       ulong header_len,
+  Query_cache_block *write_block_data(size_t data_len, uchar* data,
+				       size_t header_len,
 				       Query_cache_block::block_type type,
 				       TABLE_COUNTER_TYPE ntab = 0);
   my_bool append_result_data(Query_cache_block **result,
-			     ulong data_len, uchar* data,
+			     size_t data_len, uchar* data,
 			     Query_cache_block *parent);
   my_bool write_result_data(Query_cache_block **result,
-			    ulong data_len, uchar* data,
+			    size_t data_len, uchar* data,
 			    Query_cache_block *parent,
 			    Query_cache_block::block_type
 			    type=Query_cache_block::RESULT);
-  inline ulong get_min_first_result_data_size();
-  inline ulong get_min_append_result_data_size();
-  Query_cache_block *allocate_block(ulong len, my_bool not_less,
-				     ulong min);
+  inline size_t get_min_first_result_data_size();
+  inline size_t get_min_append_result_data_size();
+  Query_cache_block *allocate_block(size_t len, my_bool not_less,
+				     size_t min);
   /*
     If query is cacheable return number tables in query
     (query without tables not cached)
@@ -447,9 +447,9 @@ protected:
   static my_bool ask_handler_allowance(THD *thd, TABLE_LIST *tables_used);
  public:
 
-  Query_cache(ulong query_cache_limit = ULONG_MAX,
-	      ulong min_allocation_unit = QUERY_CACHE_MIN_ALLOCATION_UNIT,
-	      ulong min_result_data_size = QUERY_CACHE_MIN_RESULT_DATA_SIZE,
+  Query_cache(size_t query_cache_limit = ULONG_MAX,
+	      size_t min_allocation_unit = QUERY_CACHE_MIN_ALLOCATION_UNIT,
+	      size_t min_result_data_size = QUERY_CACHE_MIN_RESULT_DATA_SIZE,
 	      uint def_query_hash_size = QUERY_CACHE_DEF_QUERY_HASH_SIZE,
 	      uint def_table_hash_size = QUERY_CACHE_DEF_TABLE_HASH_SIZE);
 
@@ -460,11 +460,11 @@ protected:
   /* initialize cache (mutex) */
   void init();
   /* resize query cache (return real query size, 0 if disabled) */
-  ulong resize(ulong query_cache_size);
+  size_t resize(size_t query_cache_size);
   /* set limit on result size */
-  inline void result_size_limit(ulong limit){query_cache_limit=limit;}
+  inline void result_size_limit(size_t limit){query_cache_limit=limit;}
   /* set minimal result data allocation unit size */
-  ulong set_min_res_unit(ulong size);
+  size_t set_min_res_unit(size_t size);
 
   /* register query in cache */
   void store_query(THD *thd, TABLE_LIST *used_tables);
@@ -481,7 +481,7 @@ protected:
   void invalidate(THD *thd, CHANGED_TABLE_LIST *tables_used);
   void invalidate_locked_for_write(THD *thd, TABLE_LIST *tables_used);
   void invalidate(THD *thd, TABLE *table, my_bool using_transactions);
-  void invalidate(THD *thd, const char *key, uint32  key_length,
+  void invalidate(THD *thd, const char *key, size_t key_length,
 		  my_bool using_transactions);
 
   /* Remove all queries that uses any of the tables in following database */
@@ -492,18 +492,18 @@ protected:
 
   void flush();
   void pack(THD *thd,
-            ulong join_limit = QUERY_CACHE_PACK_LIMIT,
+            size_t join_limit = QUERY_CACHE_PACK_LIMIT,
 	    uint iteration_limit = QUERY_CACHE_PACK_ITERATION);
 
   void destroy();
 
   void insert(THD *thd, Query_cache_tls *query_cache_tls,
               const char *packet,
-              ulong length,
+              size_t length,
               unsigned pkt_nr);
-  my_bool insert_table(THD *thd, uint key_len, const char *key,
+  my_bool insert_table(THD *thd, size_t key_len, const char *key,
 		       Query_cache_block_table *node,
-		       uint32 db_length, uint8 suffix_length_arg,
+		       size_t db_length, uint8 suffix_length_arg,
                        uint8 cache_type,
 		       qc_engine_callback callback,
 		       ulonglong engine_data,
@@ -562,8 +562,8 @@ struct Query_cache_query_flags
   sql_mode_t sql_mode;
   ulonglong max_sort_length;
   ulonglong group_concat_max_len;
-  ulong default_week_format;
-  ulong div_precision_increment;
+  size_t default_week_format;
+  size_t div_precision_increment;
   MY_LOCALE *lc_time_names;
 };
 #define QUERY_CACHE_FLAGS_SIZE sizeof(Query_cache_query_flags)
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 5cb6ad53b51..7ff54823da0 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -553,7 +553,7 @@ char *thd_get_error_context_description(THD *thd, char *buffer,
   String str(buffer, length, &my_charset_latin1);
   const Security_context *sctx= &thd->main_security_ctx;
   char header[256];
-  int len;
+  size_t len;
 
   /*
     The pointers thd->query and thd->proc_info might change since they are
@@ -567,8 +567,8 @@ char *thd_get_error_context_description(THD *thd, char *buffer,
   const char *proc_info= thd->proc_info;
 
   len= my_snprintf(header, sizeof(header),
-                   "MySQL thread id %lu, OS thread handle %lu, query id %lu",
-                   (ulong) thd->thread_id, (ulong) thd->real_id, (ulong) thd->query_id);
+                   "MySQL thread id %u, OS thread handle %lu, query id %llu",
+                    (uint)thd->thread_id, (ulong) thd->real_id, (ulonglong) thd->query_id);
   str.length(0);
   str.append(header, len);
 
@@ -2356,7 +2356,7 @@ void THD::cleanup_after_query()
 */
 
 bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
-			 const char *from, uint from_length,
+			 const char *from, size_t from_length,
 			 CHARSET_INFO *from_cs)
 {
   DBUG_ENTER("THD::convert_string");
@@ -2383,7 +2383,7 @@ bool THD::convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
   dstcs and srccs cannot be &my_charset_bin.
 */
 bool THD::convert_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
-                      CHARSET_INFO *srccs, const char *src, uint src_length,
+                      CHARSET_INFO *srccs, const char *src, size_t src_length,
                       String_copier *status)
 {
   DBUG_ENTER("THD::convert_fix");
@@ -2401,7 +2401,7 @@ bool THD::convert_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
   Copy or convert a string.
 */
 bool THD::copy_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
-                   CHARSET_INFO *srccs, const char *src, uint src_length,
+                   CHARSET_INFO *srccs, const char *src, size_t src_length,
                    String_copier *status)
 {
   DBUG_ENTER("THD::copy_fix");
@@ -2418,7 +2418,7 @@ bool THD::copy_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
 class String_copier_with_error: public String_copier
 {
 public:
-  bool check_errors(CHARSET_INFO *srccs, const char *src, uint src_length)
+  bool check_errors(CHARSET_INFO *srccs, const char *src, size_t src_length)
   {
     if (most_important_error_pos())
     {
@@ -2433,7 +2433,7 @@ public:
 
 bool THD::convert_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst,
                              CHARSET_INFO *srccs,
-                             const char *src, uint src_length)
+                             const char *src, size_t src_length)
 {
   String_copier_with_error status;
   return convert_fix(dstcs, dst, srccs, src, src_length, &status) ||
@@ -2443,7 +2443,7 @@ bool THD::convert_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst,
 
 bool THD::copy_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst,
                           CHARSET_INFO *srccs,
-                          const char *src, uint src_length)
+                          const char *src, size_t src_length)
 {
   String_copier_with_error status;
   return copy_fix(dstcs, dst, srccs, src, src_length, &status) ||
@@ -2498,7 +2498,7 @@ Item *THD::make_string_literal(const char *str, size_t length,
     str= to.str;
     length= to.length;
   }
-  return new (mem_root) Item_string(this, str, length,
+  return new (mem_root) Item_string(this, str, (uint)length,
                                     variables.collation_connection,
                                     DERIVATION_COERCIBLE, repertoire);
 }
@@ -2510,7 +2510,7 @@ Item *THD::make_string_literal_nchar(const Lex_string_with_metadata_st &str)
   if (!str.length && (variables.sql_mode & MODE_EMPTY_STRING_IS_NULL))
     return new (mem_root) Item_null(this, 0, national_charset_info);
 
-  return new (mem_root) Item_string(this, str.str, str.length,
+  return new (mem_root) Item_string(this, str.str, (uint)str.length,
                                     national_charset_info,
                                     DERIVATION_COERCIBLE,
                                     str.repertoire());
@@ -2523,7 +2523,7 @@ Item *THD::make_string_literal_charset(const Lex_string_with_metadata_st &str,
   if (!str.length && (variables.sql_mode & MODE_EMPTY_STRING_IS_NULL))
     return new (mem_root) Item_null(this, 0, cs);
   return new (mem_root) Item_string_with_introducer(this,
-                                                    str.str, str.length, cs);
+                                                    str.str, (uint)str.length, cs);
 }
 
 
@@ -2536,7 +2536,7 @@ Item *THD::make_string_literal_concat(Item *item, const LEX_CSTRING &str)
     {
       CHARSET_INFO *cs= variables.collation_connection;
       uint repertoire= my_string_repertoire(cs, str.str, str.length);
-      return new (mem_root) Item_string(this, str.str, str.length, cs,
+      return new (mem_root) Item_string(this, str.str, (uint)str.length, cs,
                                         DERIVATION_COERCIBLE, repertoire);
     }
     return item;
@@ -2544,7 +2544,7 @@ Item *THD::make_string_literal_concat(Item *item, const LEX_CSTRING &str)
 
   DBUG_ASSERT(item->type() == Item::STRING_ITEM);
   DBUG_ASSERT(item->basic_const_item());
-  static_cast<Item_string*>(item)->append(str.str, str.length);
+  static_cast<Item_string*>(item)->append(str.str, (uint)str.length);
   if (!(item->collation.repertoire & MY_REPERTOIRE_EXTENDED))
   {
     // If the string has been pure ASCII so far, check the new part.
@@ -2606,7 +2606,7 @@ void THD::add_changed_table(TABLE *table)
 }
 
 
-void THD::add_changed_table(const char *key, long key_length)
+void THD::add_changed_table(const char *key, size_t key_length)
 {
   DBUG_ENTER("THD::add_changed_table(key)");
   CHANGED_TABLE_LIST **prev_changed = &transaction.changed_tables;
@@ -2619,7 +2619,7 @@ void THD::add_changed_table(const char *key, long key_length)
     {
       list_include(prev_changed, curr, changed_table_dup(key, key_length));
       DBUG_PRINT("info", 
-		 ("key_length: %ld  %u", key_length,
+		 ("key_length: %zu  %zu", key_length,
                   (*prev_changed)->key_length));
       DBUG_VOID_RETURN;
     }
@@ -2630,7 +2630,7 @@ void THD::add_changed_table(const char *key, long key_length)
       {
 	list_include(prev_changed, curr, changed_table_dup(key, key_length));
 	DBUG_PRINT("info", 
-		   ("key_length:  %ld  %u", key_length,
+		   ("key_length:  %zu  %zu", key_length,
 		    (*prev_changed)->key_length));
 	DBUG_VOID_RETURN;
       }
@@ -2642,13 +2642,13 @@ void THD::add_changed_table(const char *key, long key_length)
     }
   }
   *prev_changed = changed_table_dup(key, key_length);
-  DBUG_PRINT("info", ("key_length: %ld  %u", key_length,
+  DBUG_PRINT("info", ("key_length: %zu  %zu", key_length,
 		      (*prev_changed)->key_length));
   DBUG_VOID_RETURN;
 }
 
 
-CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, long key_length)
+CHANGED_TABLE_LIST* THD::changed_table_dup(const char *key, size_t key_length)
 {
   CHANGED_TABLE_LIST* new_table = 
     (CHANGED_TABLE_LIST*) trans_alloc(ALIGN_SIZE(sizeof(CHANGED_TABLE_LIST))+
@@ -4256,7 +4256,7 @@ void TMP_TABLE_PARAM::init()
 }
 
 
-void thd_increment_bytes_sent(void *thd, ulong length)
+void thd_increment_bytes_sent(void *thd, size_t length)
 {
   /* thd == 0 when close_connection() calls net_send_error() */
   if (likely(thd != 0))
@@ -4272,19 +4272,13 @@ my_bool thd_net_is_killed()
 }
 
 
-void thd_increment_bytes_received(void *thd, ulong length)
+void thd_increment_bytes_received(void *thd, size_t length)
 {
   if (thd != NULL) // MDEV-13073 Ack collector having NULL
     ((THD*) thd)->status_var.bytes_received+= length;
 }
 
 
-void thd_increment_net_big_packet_count(void *thd, ulong length)
-{
-  ((THD*) thd)->status_var.net_big_packet_count+= length;
-}
-
-
 void THD::set_status_var_init()
 {
   bzero((char*) &status_var, offsetof(STATUS_VAR,
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 9775aa71193..1c3d5f2bff5 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -194,7 +194,7 @@ typedef struct st_user_var_events
 {
   user_var_entry *user_var_event;
   char *value;
-  ulong length;
+  size_t length;
   Item_result type;
   uint charset_number;
   bool unsigned_flag;
@@ -775,7 +775,6 @@ typedef struct system_status_var
   ulong ha_savepoint_rollback_count;
   ulong ha_external_lock_count;
 
-  ulong net_big_packet_count;
   ulong opened_tables;
   ulong opened_shares;
   ulong opened_views;               /* +1 opening a view */
@@ -1002,7 +1001,7 @@ public:
   { return strmake_root(mem_root,str,size); }
   inline void *memdup(const void *str, size_t size)
   { return memdup_root(mem_root,str,size); }
-  inline void *memdup_w_gap(const void *str, size_t size, uint gap)
+  inline void *memdup_w_gap(const void *str, size_t size, size_t gap)
   {
     void *ptr;
     if ((ptr= alloc_root(mem_root,size+gap)))
@@ -3547,12 +3546,12 @@ public:
   {
     return !stmt_arena->is_stmt_prepare();
   }
-  inline void* trans_alloc(unsigned int size)
+  inline void* trans_alloc(size_t size)
   {
     return alloc_root(&transaction.mem_root,size);
   }
 
-  LEX_STRING *make_lex_string(LEX_STRING *lex_str, const char* str, uint length)
+  LEX_STRING *make_lex_string(LEX_STRING *lex_str, const char* str, size_t length)
   {
     if (!(lex_str->str= strmake_root(mem_root, str, length)))
     {
@@ -3562,7 +3561,7 @@ public:
     lex_str->length= length;
     return lex_str;
   }
-  LEX_CSTRING *make_lex_string(LEX_CSTRING *lex_str, const char* str, uint length)
+  LEX_CSTRING *make_lex_string(LEX_CSTRING *lex_str, const char* str, size_t length)
   {
     if (!(lex_str->str= strmake_root(mem_root, str, length)))
     {
@@ -3573,7 +3572,7 @@ public:
     return lex_str;
   }
 
-  LEX_CSTRING *make_clex_string(const char* str, uint length)
+  LEX_CSTRING *make_clex_string(const char* str, size_t length)
   {
     LEX_CSTRING *lex_str;
     char *tmp;
@@ -3589,7 +3588,7 @@ public:
   }
 
   // Allocate LEX_STRING for character set conversion
-  bool alloc_lex_string(LEX_STRING *dst, uint length)
+  bool alloc_lex_string(LEX_STRING *dst, size_t length)
   {
     if ((dst->str= (char*) alloc(length)))
       return false;
@@ -3597,7 +3596,7 @@ public:
     return true;     // EOM
   }
   bool convert_string(LEX_STRING *to, CHARSET_INFO *to_cs,
-		      const char *from, uint from_length,
+		      const char *from, size_t from_length,
 		      CHARSET_INFO *from_cs);
   /*
     Convert a strings between character sets.
@@ -3605,7 +3604,7 @@ public:
     dstcs and srccs cannot be &my_charset_bin.
   */
   bool convert_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
-                   CHARSET_INFO *srccs, const char *src, uint src_length,
+                   CHARSET_INFO *srccs, const char *src, size_t src_length,
                    String_copier *status);
 
   /*
@@ -3614,7 +3613,7 @@ public:
   */
   bool convert_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst,
                           CHARSET_INFO *srccs,
-                          const char *src, uint src_length);
+                          const char *src, size_t src_length);
 
   /*
     If either "dstcs" or "srccs" is &my_charset_bin,
@@ -3622,7 +3621,7 @@ public:
     Otherwise, performs Unicode conversion using convert_fix().
   */
   bool copy_fix(CHARSET_INFO *dstcs, LEX_STRING *dst,
-                CHARSET_INFO *srccs, const char *src, uint src_length,
+                CHARSET_INFO *srccs, const char *src, size_t src_length,
                 String_copier *status);
 
   /*
@@ -3630,7 +3629,7 @@ public:
     in case of bad byte sequences or Unicode conversion problems.
   */
   bool copy_with_error(CHARSET_INFO *dstcs, LEX_STRING *dst,
-                       CHARSET_INFO *srccs, const char *src, uint src_length);
+                       CHARSET_INFO *srccs, const char *src, size_t src_length);
 
   bool convert_string(String *s, CHARSET_INFO *from_cs, CHARSET_INFO *to_cs);
 
@@ -3652,8 +3651,8 @@ public:
                                     CHARSET_INFO *cs);
   Item *make_string_literal_concat(Item *item1, const LEX_CSTRING &str);
   void add_changed_table(TABLE *table);
-  void add_changed_table(const char *key, long key_length);
-  CHANGED_TABLE_LIST * changed_table_dup(const char *key, long key_length);
+  void add_changed_table(const char *key, size_t key_length);
+  CHANGED_TABLE_LIST * changed_table_dup(const char *key, size_t key_length);
   int send_explain_fields(select_result *result, uint8 explain_flags,
                           bool is_analyze);
   void make_explain_field_list(List<Item> &field_list, uint8 explain_flags,
@@ -4233,12 +4232,12 @@ public:
     Assign a new value to thd->query and thd->query_id and mysys_var.
     Protected with LOCK_thd_data mutex.
   */
-  void set_query(char *query_arg, uint32 query_length_arg,
+  void set_query(char *query_arg, size_t query_length_arg,
                  CHARSET_INFO *cs_arg)
   {
     set_query(CSET_STRING(query_arg, query_length_arg, cs_arg));
   }
-  void set_query(char *query_arg, uint32 query_length_arg) /*Mutex protected*/
+  void set_query(char *query_arg, size_t query_length_arg) /*Mutex protected*/
   {
     set_query(CSET_STRING(query_arg, query_length_arg, charset()));
   }
@@ -4443,7 +4442,7 @@ public:
   TMP_TABLE_SHARE *find_tmp_table_share(const char *db,
                                         const char *table_name);
   TMP_TABLE_SHARE *find_tmp_table_share(const TABLE_LIST *tl);
-  TMP_TABLE_SHARE *find_tmp_table_share(const char *key, uint key_length);
+  TMP_TABLE_SHARE *find_tmp_table_share(const char *key, size_t key_length);
 
   bool open_temporary_table(TABLE_LIST *tl);
   bool open_temporary_tables(TABLE_LIST *tl);
@@ -5704,7 +5703,7 @@ class user_var_entry
   user_var_entry() {}                         /* Remove gcc warning */
   LEX_CSTRING name;
   char *value;
-  ulong length;
+  size_t length;
   query_id_t update_query_id, used_query_id;
   Item_result type;
   bool unsigned_flag;
@@ -6187,7 +6186,7 @@ void thd_exit_cond(MYSQL_THD thd, const PSI_stage_info *stage,
 #define THD_EXIT_COND(P1, P2) \
   thd_exit_cond(P1, P2, __func__, __FILE__, __LINE__)
 
-inline bool binlog_should_compress(ulong len)
+inline bool binlog_should_compress(size_t len)
 {
   return opt_bin_log_compress &&
     len >= opt_bin_log_compress_min_len;
diff --git a/sql/sql_connect.cc b/sql/sql_connect.cc
index af9e2ad8b24..7ac8bc7cadd 100644
--- a/sql/sql_connect.cc
+++ b/sql/sql_connect.cc
@@ -86,7 +86,7 @@ int get_or_create_user_conn(THD *thd, const char *user,
     uc->user=(char*) (uc+1);
     memcpy(uc->user,temp_user,temp_len+1);
     uc->host= uc->user + user_len +  1;
-    uc->len= temp_len;
+    uc->len= (uint)temp_len;
     uc->connections= uc->questions= uc->updates= uc->conn_per_hour= 0;
     uc->user_resources= *mqh;
     uc->reset_utime= thd->thr_create_utime;
@@ -339,7 +339,7 @@ void reset_mqh(LEX_USER *lu, bool get_them= 0)
   if (lu)  // for GRANT
   {
     USER_CONN *uc;
-    uint temp_len=lu->user.length+lu->host.length+2;
+    size_t temp_len=lu->user.length+lu->host.length+2;
     char temp_user[USER_HOST_BUFF_SIZE];
 
     memcpy(temp_user,lu->user.str,lu->user.length);
@@ -445,7 +445,7 @@ void init_user_stats(USER_STATS *user_stats,
   user_length= MY_MIN(user_length, sizeof(user_stats->user)-1);
   memcpy(user_stats->user, user, user_length);
   user_stats->user[user_length]= 0;
-  user_stats->user_name_length= user_length;
+  user_stats->user_name_length= (uint)user_length;
   strmake_buf(user_stats->priv_user, priv_user);
 
   user_stats->total_connections= total_connections;
diff --git a/sql/sql_cte.cc b/sql/sql_cte.cc
index a53e6b07813..ea7ff138f10 100644
--- a/sql/sql_cte.cc
+++ b/sql/sql_cte.cc
@@ -826,7 +826,7 @@ st_select_lex_unit *With_element::clone_parsed_spec(THD *thd,
   TABLE_LIST *spec_tables_tail;
   st_select_lex *with_select;
 
-  if (parser_state.init(thd, (char*) unparsed_spec.str, unparsed_spec.length))
+  if (parser_state.init(thd, (char*) unparsed_spec.str, (unsigned int)unparsed_spec.length))
     goto err;
   lex_start(thd);
   with_select= &lex->select_lex;
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 417e3959e85..114c06fdf2e 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -122,12 +122,12 @@ uchar* dboptions_get_key(my_dbopt_t *opt, size_t *length,
   Helper function to write a query to binlog used by mysql_rm_db()
 */
 
-static inline int write_to_binlog(THD *thd, const char *query, uint q_len,
-                                  const char *db, uint db_len)
+static inline int write_to_binlog(THD *thd, const char *query, size_t q_len,
+                                  const char *db, size_t db_len)
 {
   Query_log_event qinfo(thd, query, q_len, FALSE, TRUE, FALSE, 0);
   qinfo.db= db;
-  qinfo.db_len= db_len;
+  qinfo.db_len= (uint32)db_len;
   return mysql_bin_log.write(&qinfo);
 }  
 
@@ -388,7 +388,7 @@ bool load_db_opt(THD *thd, const char *path, Schema_specification_st *create)
   char buf[256];
   DBUG_ENTER("load_db_opt");
   bool error=1;
-  uint nbytes;
+  size_t nbytes;
 
   bzero((char*) create,sizeof(*create));
   create->default_table_charset= thd->variables.collation_server;
@@ -688,7 +688,7 @@ not_silent:
                                       # database does not exist.
       */
       qinfo.db     = db->str;
-      qinfo.db_len = db->length;
+      qinfo.db_len = (uint32)db->length;
 
       /*
         These DDL methods and logging are protected with the exclusive
@@ -748,7 +748,7 @@ mysql_alter_db_internal(THD *thd, const LEX_CSTRING *db,
       default.
     */
     qinfo.db=     db->str;
-    qinfo.db_len= db->length;
+    qinfo.db_len= (uint)db->length;
 
     /*
       These DDL methods and logging are protected with the exclusive
@@ -958,7 +958,7 @@ update_binlog:
         default.
       */
       qinfo.db     = db->str;
-      qinfo.db_len = db->length;
+      qinfo.db_len = (uint32)db->length;
 
       /*
         These DDL methods and logging are protected with the exclusive
@@ -986,7 +986,7 @@ update_binlog:
 
     for (tbl= tables; tbl; tbl= tbl->next_local)
     {
-      uint tbl_name_len;
+      size_t tbl_name_len;
       char quoted_name[FN_REFLEN+3];
 
       // Only write drop table to the binlog for tables that no longer exist.
diff --git a/sql/sql_digest.cc b/sql/sql_digest.cc
index 2f88d62fbbb..54ed1c3f225 100644
--- a/sql/sql_digest.cc
+++ b/sql/sql_digest.cc
@@ -149,7 +149,7 @@ inline void store_token_identifier(sql_digest_storage* digest_storage,
     /* Write the string data */
     if (id_length > 0)
       memcpy((char *)(dest + 4), id_name, id_length);
-    digest_storage->m_byte_count+= bytes_needed;
+    digest_storage->m_byte_count+= (uint)bytes_needed;
   }
   else
   {
diff --git a/sql/sql_digest.h b/sql/sql_digest.h
index eaf74b9542e..81fe809b59d 100644
--- a/sql/sql_digest.h
+++ b/sql/sql_digest.h
@@ -54,10 +54,10 @@ struct sql_digest_storage
     reset(NULL, 0);
   }
 
-  inline void reset(unsigned char *token_array, uint length)
+  inline void reset(unsigned char *token_array, size_t length)
   {
     m_token_array= token_array;
-    m_token_array_length= length;
+    m_token_array_length= (uint)length;
     reset();
   }
 
diff --git a/sql/sql_error.cc b/sql/sql_error.cc
index 24fb934c279..67440aeed33 100644
--- a/sql/sql_error.cc
+++ b/sql/sql_error.cc
@@ -523,8 +523,7 @@ Warning_info::~Warning_info()
 }
 
 
-bool Warning_info::has_sql_condition(const char *message_str,
-                                     ulong message_length) const
+bool Warning_info::has_sql_condition(const char *message_str, size_t message_length) const
 {
   Diagnostics_area::Sql_condition_iterator it(m_warn_list);
   const Sql_condition *err;
@@ -918,11 +917,11 @@ char *err_conv(char *buff, uint to_length, const char *from,
    length of converted string
 */
 
-uint32 convert_error_message(char *to, uint32 to_length, CHARSET_INFO *to_cs,
-                             const char *from, uint32 from_length,
+size_t convert_error_message(char *to, size_t to_length, CHARSET_INFO *to_cs,
+                             const char *from, size_t from_length,
                              CHARSET_INFO *from_cs, uint *errors)
 {
-  int         cnvres;
+  int  cnvres;
   my_wc_t     wc;
   const uchar *from_end= (const uchar*) from+from_length;
   char *to_start= to;
@@ -930,7 +929,7 @@ uint32 convert_error_message(char *to, uint32 to_length, CHARSET_INFO *to_cs,
   my_charset_conv_mb_wc mb_wc= from_cs->cset->mb_wc;
   my_charset_conv_wc_mb wc_mb;
   uint error_count= 0;
-  uint length;
+  size_t length;
 
   DBUG_ASSERT(to_length > 0);
   /* Make room for the null terminator. */
@@ -969,7 +968,7 @@ uint32 convert_error_message(char *to, uint32 to_length, CHARSET_INFO *to_cs,
       length= (wc <= 0xFFFF) ? 6/* '\1234' format*/ : 9 /* '\+123456' format*/;
       if ((uchar*)(to + length) >= to_end)
         break;
-      cnvres= my_snprintf(to, 9,
+      cnvres= (int)my_snprintf(to, 9,
                           (wc <= 0xFFFF) ? "\\%04X" : "\\+%06X", (uint) wc);
       to+= cnvres;
     }
@@ -979,7 +978,7 @@ uint32 convert_error_message(char *to, uint32 to_length, CHARSET_INFO *to_cs,
 
   *to= 0;
   *errors= error_count;
-  return (uint32) (to - to_start);
+  return (size_t) (to - to_start);
 }
 
 
diff --git a/sql/sql_error.h b/sql/sql_error.h
index c74f6519129..67c6e50d283 100644
--- a/sql/sql_error.h
+++ b/sql/sql_error.h
@@ -591,7 +591,7 @@ private:
     @return true if the Warning_info contains an SQL-condition with the given
     message.
   */
-  bool has_sql_condition(const char *message_str, ulong message_length) const;
+  bool has_sql_condition(const char *message_str, size_t message_length) const;
 
   /**
     Reset the warning information. Clear all warnings,
@@ -1089,7 +1089,7 @@ public:
   ulong current_statement_warn_count() const
   { return get_warning_info()->current_statement_warn_count(); }
 
-  bool has_sql_condition(const char *message_str, ulong message_length) const
+  bool has_sql_condition(const char *message_str, size_t message_length) const
   { return get_warning_info()->has_sql_condition(message_str, message_length); }
 
   void reset_for_next_command()
@@ -1240,9 +1240,9 @@ void push_warning_printf(THD *thd, Sql_condition::enum_warning_level level,
 
 bool mysqld_show_warnings(THD *thd, ulong levels_to_show);
 
-uint32 convert_error_message(char *to, uint32 to_length,
+size_t convert_error_message(char *to, size_t to_length,
                              CHARSET_INFO *to_cs,
-                             const char *from, uint32 from_length,
+                             const char *from, size_t from_length,
                              CHARSET_INFO *from_cs, uint *errors);
 
 extern const LEX_CSTRING warning_level_names[];
diff --git a/sql/sql_explain.cc b/sql/sql_explain.cc
index ad80303e1b3..5d977c6d5c2 100644
--- a/sql/sql_explain.cc
+++ b/sql/sql_explain.cc
@@ -445,13 +445,13 @@ uint Explain_union::make_union_table_name(char *buf)
     default:
       DBUG_ASSERT(0);
   }
-  memcpy(buf, type.str, (len= type.length));
+  memcpy(buf, type.str, (len= (uint)type.length));
 
   for (; childno < union_members.elements() && len + lastop + 5 < NAME_LEN;
        childno++)
   {
     len+= lastop;
-    lastop= my_snprintf(buf + len, NAME_LEN - len,
+    lastop= (uint)my_snprintf(buf + len, NAME_LEN - len,
                         "%u,", union_members.at(childno));
   }
 
diff --git a/sql/sql_help.cc b/sql/sql_help.cc
index 80ed12b5652..da38a2caf94 100644
--- a/sql/sql_help.cc
+++ b/sql/sql_help.cc
@@ -645,7 +645,7 @@ SQL_SELECT *prepare_simple_select(THD *thd, Item *cond,
     #  created SQL_SELECT
 */
 
-SQL_SELECT *prepare_select_for_name(THD *thd, const char *mask, uint mlen,
+SQL_SELECT *prepare_select_for_name(THD *thd, const char *mask, size_t mlen,
 				    TABLE_LIST *tables, TABLE *table,
 				    Field *pfname, int *error)
 {
@@ -654,7 +654,7 @@ SQL_SELECT *prepare_select_for_name(THD *thd, const char *mask, uint mlen,
     Item_func_like(thd,
                    new (mem_root)
                    Item_field(thd, pfname),
-                   new (mem_root) Item_string(thd, mask, mlen,
+                   new (mem_root) Item_string(thd, mask, (uint)mlen,
                                               pfname->charset()),
                    new (mem_root) Item_string_ascii(thd, "\\"),
                    FALSE);
@@ -686,7 +686,7 @@ static bool mysqld_help_internal(THD *thd, const char *mask)
   List<String> topics_list, categories_list, subcategories_list;
   String name, description, example;
   int count_topics, count_categories, error;
-  uint mlen= strlen(mask);
+  size_t mlen= strlen(mask);
   size_t i;
   MEM_ROOT *mem_root= thd->mem_root;
   LEX_CSTRING MYSQL_HELP_TOPIC_NAME=    {STRING_WITH_LEN("help_topic") };
diff --git a/sql/sql_join_cache.cc b/sql/sql_join_cache.cc
index 6df92f13585..dadd419ade5 100644
--- a/sql/sql_join_cache.cc
+++ b/sql/sql_join_cache.cc
@@ -765,7 +765,7 @@ uint JOIN_CACHE::get_record_max_affix_length()
     The minimal possible size of the join buffer of this cache 
 */
 
-ulong JOIN_CACHE::get_min_join_buffer_size()
+size_t JOIN_CACHE::get_min_join_buffer_size()
 {
   if (!min_buff_size)
   {
@@ -824,7 +824,7 @@ ulong JOIN_CACHE::get_min_join_buffer_size()
     The maximum possible size of the join buffer of this cache 
 */
 
-ulong JOIN_CACHE::get_max_join_buffer_size(bool optimize_buff_size)
+size_t JOIN_CACHE::get_max_join_buffer_size(bool optimize_buff_size)
 {
   if (!max_buff_size)
   {
@@ -933,9 +933,9 @@ int JOIN_CACHE::alloc_buffer()
   if (for_explain_only)
     return 0;
                                
-  for (ulong buff_size_decr= (buff_size-min_buff_size)/4 + 1; ; )
+  for (size_t buff_size_decr= (buff_size-min_buff_size)/4 + 1; ; )
   {
-    ulong next_buff_size;
+    size_t next_buff_size;
 
     if ((buff= (uchar*) my_malloc(buff_size, MYF(MY_THREAD_SPECIFIC))))
       break;
@@ -1701,7 +1701,7 @@ enum JOIN_CACHE::Match_flag JOIN_CACHE::get_match_flag_by_pos(uchar *rec_ptr)
     the number of bytes in the increment 
 */
 
-uint JOIN_CACHE::aux_buffer_incr(ulong recno)
+uint JOIN_CACHE::aux_buffer_incr(size_t recno)
 { 
   return join_tab_scan->aux_buffer_incr(recno);
 }
@@ -2759,22 +2759,22 @@ int JOIN_CACHE_HASHED::init_hash_table()
                       size_of_key_ofs +          // reference to the next key 
                       (use_emb_key ?  get_size_of_rec_offset() : key_length);
 
-    ulong space_per_rec= avg_record_length +
+    size_t space_per_rec= avg_record_length +
                          avg_aux_buffer_incr +
                          key_entry_length+size_of_key_ofs;
-    uint n= buff_size / space_per_rec;
+    size_t n= buff_size / space_per_rec;
 
     /*
       TODO: Make a better estimate for this upper bound of
             the number of records in in the join buffer.
     */
-    uint max_n= buff_size / (pack_length-length+
+    size_t max_n= buff_size / (pack_length-length+
                              key_entry_length+size_of_key_ofs);
 
     hash_entries= (uint) (n / 0.7);
     set_if_bigger(hash_entries, 1);
     
-    if (offset_size(max_n*key_entry_length) <=
+    if (offset_size((uint)(max_n*key_entry_length)) <=
         size_of_key_ofs)
       break;
   }
@@ -3501,7 +3501,7 @@ bool JOIN_CACHE_BNL::prepare_look_for_matches(bool skip_last)
   if (!records)
     return TRUE;
   reset(FALSE);
-  rem_records= records - MY_TEST(skip_last);
+  rem_records= (uint)records - MY_TEST(skip_last);
   return rem_records == 0;
 }
 
@@ -3829,7 +3829,7 @@ int JOIN_CACHE_BNLH::init(bool for_explain)
     the increment of the size of the MRR buffer for the next record
 */
 
-uint JOIN_TAB_SCAN_MRR::aux_buffer_incr(ulong recno)
+uint JOIN_TAB_SCAN_MRR::aux_buffer_incr(size_t recno)
 {
   uint incr= 0;
   TABLE_REF *ref= &join_tab->ref;
diff --git a/sql/sql_join_cache.h b/sql/sql_join_cache.h
index 12c278dae85..c4ba08496d0 100644
--- a/sql/sql_join_cache.h
+++ b/sql/sql_join_cache.h
@@ -107,7 +107,7 @@ protected:
   /* 3 functions below actually do not use the hidden parameter 'this' */ 
 
   /* Calculate the number of bytes used to store an offset value */
-  uint offset_size(uint len)
+  uint offset_size(size_t len)
   { return (len < 256 ? 1 : len < 256*256 ? 2 : 4); }
 
   /* Get the offset value that takes ofs_sz bytes at the position ptr */
@@ -420,7 +420,7 @@ protected:
     incremented when a new record is added to the join buffer.
     If no auxiliary buffer is needed the function should return 0.
   */
-  virtual uint aux_buffer_incr(ulong recno);
+  virtual uint aux_buffer_incr(size_t recno);
 
   /* Shall calculate how much space is remaining in the join buffer */ 
   virtual size_t rem_space() 
@@ -606,9 +606,9 @@ public:
   void set_join_buffer_size(size_t sz) { buff_size= sz; }
 
   /* Get the minimum possible size of the cache join buffer */
-  virtual ulong get_min_join_buffer_size();
+  virtual size_t get_min_join_buffer_size();
   /* Get the maximum possible size of the cache join buffer */ 
-  virtual ulong get_max_join_buffer_size(bool optimize_buff_size);
+  virtual size_t get_max_join_buffer_size(bool optimize_buff_size);
 
   /* Shrink the size if the cache join buffer in a given ratio */
   bool shrink_join_buffer_in_ratio(ulonglong n, ulonglong d);
@@ -1069,7 +1069,7 @@ public:
     Shall calculate the increment of the auxiliary buffer for a record
     write if such a buffer is used by the table scan object 
   */
-  virtual uint aux_buffer_incr(ulong recno) { return 0; }
+  virtual uint aux_buffer_incr(size_t recno) { return 0; }
 
   /* Initiate the process of iteration over the joined table */
   virtual int open();
@@ -1244,7 +1244,7 @@ public:
   JOIN_TAB_SCAN_MRR(JOIN *j, JOIN_TAB *tab, uint flags, RANGE_SEQ_IF rs_funcs)
     :JOIN_TAB_SCAN(j, tab), range_seq_funcs(rs_funcs), mrr_mode(flags) {}
 
-  uint aux_buffer_incr(ulong recno);
+  uint aux_buffer_incr(size_t recno);
 
   int open();
  
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 0106f189ca8..0899082ca98 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -258,7 +258,7 @@ st_parsing_options::reset()
 
 bool Lex_input_stream::init(THD *thd,
 			    char* buff,
-			    unsigned int length)
+			    size_t length)
 {
   DBUG_EXECUTE_IF("bug42064_simulate_oom",
                   DBUG_SET("+d,simulate_out_of_memory"););
@@ -269,12 +269,12 @@ bool Lex_input_stream::init(THD *thd,
                   DBUG_SET("-d,bug42064_simulate_oom");); 
 
   if (m_cpp_buf == NULL)
-    return TRUE;
+    return true;
 
   m_thd= thd;
   reset(buff, length);
 
-  return FALSE;
+  return false;
 }
 
 
@@ -287,7 +287,7 @@ bool Lex_input_stream::init(THD *thd,
 */
 
 void
-Lex_input_stream::reset(char *buffer, unsigned int length)
+Lex_input_stream::reset(char *buffer, size_t length)
 {
   yylineno= 1;
   yylval= NULL;
@@ -334,7 +334,7 @@ void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr)
   DBUG_ASSERT(begin_ptr);
   DBUG_ASSERT(m_cpp_buf <= begin_ptr && begin_ptr <= m_cpp_buf + m_buf_length);
 
-  uint body_utf8_length= get_body_utf8_maximum_length(thd);
+  size_t body_utf8_length= get_body_utf8_maximum_length(thd);
 
   m_body_utf8= (char *) thd->alloc(body_utf8_length + 1);
   m_body_utf8_ptr= m_body_utf8;
@@ -344,7 +344,7 @@ void Lex_input_stream::body_utf8_start(THD *thd, const char *begin_ptr)
 }
 
 
-uint Lex_input_stream::get_body_utf8_maximum_length(THD *thd)
+size_t Lex_input_stream::get_body_utf8_maximum_length(THD *thd)
 {
   /*
     String literals can grow during escaping:
@@ -2151,7 +2151,7 @@ static int lex_one_token(YYSTYPE *yylval, THD *thd)
 }
 
 
-void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str, uint *prefix_length)
+void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str, size_t * prefix_length)
 {
   /*
     TODO:
@@ -2159,14 +2159,15 @@ void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str, uint *prefix_length)
     that can be considered white-space.
   */
 
-  *prefix_length= 0;
+  size_t plen= 0;
   while ((str->length > 0) && (my_isspace(cs, str->str[0])))
   {
-    (*prefix_length)++;
+    plen++;
     str->length --;
     str->str ++;
   }
-
+  if (prefix_length)
+    *prefix_length= plen;
   /*
     FIXME:
     Also, parsing backward is not safe with multi bytes characters
@@ -3871,7 +3872,7 @@ void st_select_lex::alloc_index_hints (THD *thd)
   RETURN VALUE
     0 on success, non-zero otherwise
 */
-bool st_select_lex::add_index_hint (THD *thd, const char *str, uint length)
+bool st_select_lex::add_index_hint (THD *thd, const char *str, size_t length)
 {
   return index_hints->push_front(new (thd->mem_root) 
                                  Index_hint(current_index_hint_type,
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index 058bd639e44..3505165196f 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -420,7 +420,7 @@ public:
   LEX_CSTRING key_name;
 
   Index_hint (enum index_hint_type type_arg, index_clause_map clause_arg,
-              const char *str, uint length) :
+              const char *str, size_t length) :
     type(type_arg), clause(clause_arg)
   {
     key_name.str= str;
@@ -1169,7 +1169,7 @@ public:
    Add a index hint to the tagged list of hints. The type and clause of the
    hint will be the current ones (set by set_index_hint()) 
   */
-  bool add_index_hint (THD *thd, const char *str, uint length);
+  bool add_index_hint (THD *thd, const char *str, size_t length);
 
   /* make a list to hold index hints */
   void alloc_index_hints (THD *thd);
@@ -2069,9 +2069,9 @@ public:
      @retval FALSE OK
      @retval TRUE  Error
   */
-  bool init(THD *thd, char *buff, unsigned int length);
+  bool init(THD *thd, char *buff, size_t length);
 
-  void reset(char *buff, unsigned int length);
+  void reset(char *buff, size_t length);
 
   /**
     Set the echo mode.
@@ -2344,16 +2344,16 @@ public:
   }
 
   /** Get the utf8-body length. */
-  uint get_body_utf8_length()
+  size_t get_body_utf8_length()
   {
-    return (uint) (m_body_utf8_ptr - m_body_utf8);
+    return (size_t) (m_body_utf8_ptr - m_body_utf8);
   }
 
   /**
     Get the maximum length of the utf8-body buffer.
     The utf8 body can grow because of the character set conversion and escaping.
   */
-  uint get_body_utf8_maximum_length(THD *thd);
+  size_t get_body_utf8_maximum_length(THD *thd);
 
   void body_utf8_start(THD *thd, const char *begin_ptr);
   void body_utf8_append(const char *ptr);
@@ -2413,7 +2413,7 @@ private:
   const char *m_buf;
 
   /** Length of the raw buffer. */
-  uint m_buf_length;
+  size_t m_buf_length;
 
   /** Echo the parsed stream to the pre-processed buffer. */
   bool m_echo;
@@ -3865,7 +3865,7 @@ public:
      @retval FALSE OK
      @retval TRUE  Error
   */
-  bool init(THD *thd, char *buff, unsigned int length)
+  bool init(THD *thd, char *buff, size_t length)
   {
     return m_lip.init(thd, buff, length);
   }
@@ -3997,10 +3997,9 @@ int init_lex_with_single_table(THD *thd, TABLE *table, LEX *lex);
 extern int MYSQLlex(union YYSTYPE *yylval, THD *thd);
 extern int ORAlex(union YYSTYPE *yylval, THD *thd);
 
-extern void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str,
-                            uint *prefix_removed);
+extern void trim_whitespace(CHARSET_INFO *cs, LEX_CSTRING *str, size_t * prefix_length = 0);
 
-extern bool is_lex_native_function(const LEX_CSTRING *name);
+extern bool is_lex_native_function(const LEX_CSTRING *name); 
 extern bool is_native_function(THD *thd, const LEX_CSTRING *name);
 extern bool is_native_function_with_warn(THD *thd, const LEX_CSTRING *name);
 
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 19889dbf1c5..0eb1fed9eff 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -923,7 +923,7 @@ void execute_init_command(THD *thd, LEX_STRING *init_command,
   save_vio= thd->net.vio;
   thd->net.vio= 0;
   thd->clear_error(1);
-  dispatch_command(COM_QUERY, thd, buf, len, FALSE, FALSE);
+  dispatch_command(COM_QUERY, thd, buf, (uint)len, FALSE, FALSE);
   thd->client_capabilities= save_client_capabilities;
   thd->net.vio= save_vio;
 
@@ -936,7 +936,7 @@ void execute_init_command(THD *thd, LEX_STRING *init_command,
 static char *fgets_fn(char *buffer, size_t size, fgets_input_t input, int *error)
 {
   MYSQL_FILE *in= static_cast<MYSQL_FILE*> (input);
-  char *line= mysql_file_fgets(buffer, size, in);
+  char *line= mysql_file_fgets(buffer, (int)size, in);
   if (error)
     *error= (line == NULL) ? ferror(in->m_file) : 0;
   return line;
@@ -1483,7 +1483,7 @@ static bool deny_updates_if_read_only_option(THD *thd, TABLE_LIST *all_tables)
   @retval # - Number of commands in the batch
 */
 
-uint maria_multi_check(THD *thd, char *packet, uint packet_length)
+uint maria_multi_check(THD *thd, char *packet, size_t packet_length)
 {
   uint counter= 0;
   DBUG_ENTER("maria_multi_check");
@@ -2166,7 +2166,6 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
   {
     STATUS_VAR *current_global_status_var;      // Big; Don't allocate on stack
     ulong uptime;
-    uint length __attribute__((unused));
     ulonglong queries_per_second1000;
     char buff[250];
     uint buff_len= sizeof(buff);
@@ -2181,8 +2180,10 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
       queries_per_second1000= 0;
     else
       queries_per_second1000= thd->query_id * 1000 / uptime;
-
-    length= my_snprintf(buff, buff_len - 1,
+#ifndef EMBEDDED_LIBRARY
+    size_t length=
+#endif
+    my_snprintf(buff, buff_len - 1,
                         "Uptime: %lu  Threads: %d  Questions: %lu  "
                         "Slow queries: %lu  Opens: %lu  Flush tables: %lld  "
                         "Open tables: %u  Queries per second avg: %u.%03u",
@@ -2309,7 +2310,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
         }
 
         if (dispatch_command(subcommand, thd, packet + (1 + length_length),
-                             subpacket_length - (1 + length_length), TRUE,
+                             (uint)(subpacket_length - (1 + length_length)), TRUE,
                              (current_com != counter)))
         {
           DBUG_ASSERT(thd->is_error());
@@ -2318,7 +2319,7 @@ bool dispatch_command(enum enum_server_command command, THD *thd,
 
         DBUG_ASSERT(subpacket_length <= packet_length);
         packet+= subpacket_length;
-        packet_length-= subpacket_length;
+        packet_length-= (uint)subpacket_length;
       }
 
 com_multi_end:
@@ -2627,7 +2628,7 @@ int prepare_schema_table(THD *thd, LEX *lex, Table_ident *table_ident,
     TRUE  error;  In this case thd->fatal_error is set
 */
 
-bool alloc_query(THD *thd, const char *packet, uint packet_length)
+bool alloc_query(THD *thd, const char *packet, size_t packet_length)
 {
   char *query;
   /* Remove garbage at start and end of query */
@@ -7455,16 +7456,16 @@ bool check_stack_overrun(THD *thd, long margin,
 #define MY_YACC_INIT 1000			// Start with big alloc
 #define MY_YACC_MAX  32000			// Because of 'short'
 
-bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, ulong *yystacksize)
+bool my_yyoverflow(short **yyss, YYSTYPE **yyvs, size_t *yystacksize)
 {
   Yacc_state *state= & current_thd->m_parser_state->m_yacc;
-  ulong old_info=0;
+  size_t old_info=0;
   DBUG_ASSERT(state);
-  if ((uint) *yystacksize >= MY_YACC_MAX)
+  if ( *yystacksize >= MY_YACC_MAX)
     return 1;
   if (!state->yacc_yyvs)
     old_info= *yystacksize;
-  *yystacksize= set_zone((*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
+  *yystacksize= set_zone((int)(*yystacksize)*2,MY_YACC_INIT,MY_YACC_MAX);
   if (!(state->yacc_yyvs= (uchar*)
         my_realloc(state->yacc_yyvs,
                    *yystacksize*sizeof(**yyvs),
@@ -9760,7 +9761,7 @@ LEX_USER *create_definer(THD *thd, LEX_CSTRING *user_name,
 */
 
 bool check_string_byte_length(const LEX_CSTRING *str, uint err_msg,
-                              uint max_byte_length)
+                              size_t max_byte_length)
 {
   if (str->length <= max_byte_length)
     return FALSE;
@@ -9790,7 +9791,7 @@ bool check_string_byte_length(const LEX_CSTRING *str, uint err_msg,
 
 
 bool check_string_char_length(const LEX_CSTRING *str, uint err_msg,
-                              uint max_char_length, CHARSET_INFO *cs,
+                              size_t max_char_length, CHARSET_INFO *cs,
                               bool no_error)
 {
   Well_formed_prefix prefix(cs, str->str, str->length, max_char_length);
@@ -9834,7 +9835,7 @@ extern "C" {
 
 int path_starts_from_data_home_dir(const char *path)
 {
-  int dir_len= strlen(path);
+  size_t dir_len= strlen(path);
   DBUG_ENTER("path_starts_from_data_home_dir");
 
   if (mysql_unpacked_real_data_home_len<= dir_len)
diff --git a/sql/sql_parse.h b/sql/sql_parse.h
index 7c980823fc2..d23da6f1b68 100644
--- a/sql/sql_parse.h
+++ b/sql/sql_parse.h
@@ -73,9 +73,9 @@ LEX_USER *create_definer(THD *thd, LEX_CSTRING *user_name, LEX_CSTRING *host_nam
 LEX_USER *get_current_user(THD *thd, LEX_USER *user, bool lock=true);
 bool sp_process_definer(THD *thd);
 bool check_string_byte_length(const LEX_CSTRING *str, uint err_msg,
-                              uint max_byte_length);
+                              size_t max_byte_length);
 bool check_string_char_length(const LEX_CSTRING *str, uint err_msg,
-                              uint max_char_length, CHARSET_INFO *cs,
+                              size_t max_char_length, CHARSET_INFO *cs,
                               bool no_error);
 bool check_ident_length(const LEX_CSTRING *ident);
 CHARSET_INFO* merge_charset_and_collation(CHARSET_INFO *cs, CHARSET_INFO *cl);
@@ -87,7 +87,7 @@ bool mysql_test_parse_for_slave(THD *thd,char *inBuf,uint length);
 bool sqlcom_can_generate_row_events(const THD *thd);
 bool is_update_query(enum enum_sql_command command);
 bool is_log_table_write_query(enum enum_sql_command command);
-bool alloc_query(THD *thd, const char *packet, uint packet_length);
+bool alloc_query(THD *thd, const char *packet, size_t packet_length);
 void mysql_init_select(LEX *lex);
 void mysql_parse(THD *thd, char *rawbuf, uint length,
                  Parser_state *parser_state, bool is_com_multi,
diff --git a/sql/sql_partition.cc b/sql/sql_partition.cc
index 9b5f6ebc7df..a4d940670e5 100644
--- a/sql/sql_partition.cc
+++ b/sql/sql_partition.cc
@@ -1863,7 +1863,7 @@ static int add_keyword_path(String *str, const char *keyword,
 #ifdef __WIN__
   /* Convert \ to / to be able to create table on unix */
   char *pos, *end;
-  uint length= strlen(temp_path);
+  size_t length= strlen(temp_path);
   for (pos= temp_path, end= pos+length ; pos < end ; pos++)
   {
     if (*pos == '\\')
diff --git a/sql/sql_plugin.cc b/sql/sql_plugin.cc
index d5f1e88bc11..d733e6c3684 100644
--- a/sql/sql_plugin.cc
+++ b/sql/sql_plugin.cc
@@ -240,7 +240,7 @@ ulong dlopen_count;
   the following variables/structures
 */
 static MEM_ROOT plugin_vars_mem_root;
-static uint global_variables_dynamic_size= 0;
+static size_t global_variables_dynamic_size= 0;
 static HASH bookmark_hash;
 
 
@@ -730,7 +730,8 @@ static st_plugin_dl *plugin_dl_add(const LEX_CSTRING *dl, int report)
 {
 #ifdef HAVE_DLOPEN
   char dlpath[FN_REFLEN];
-  uint plugin_dir_len, dummy_errors, i;
+  size_t plugin_dir_len,i;
+  uint dummy_errors;
   struct st_plugin_dl *tmp= 0, plugin_dl;
   void *sym;
   st_ptr_backup tmp_backup[array_elements(list_of_services)];
@@ -1518,14 +1519,14 @@ uchar *get_bookmark_hash_key(const uchar *buff, size_t *length,
   return (uchar*) var->key;
 }
 
-static inline void convert_dash_to_underscore(char *str, int len)
+static inline void convert_dash_to_underscore(char *str, size_t len)
 {
   for (char *p= str; p <= str+len; p++)
     if (*p == '-')
       *p= '_';
 }
 
-static inline void convert_underscore_to_dash(char *str, int len)
+static inline void convert_underscore_to_dash(char *str, size_t len)
 {
   for (char *p= str; p <= str+len; p++)
     if (*p == '_')
@@ -2885,7 +2886,7 @@ static st_bookmark *find_bookmark(const char *plugin, const char *name,
                                   int flags)
 {
   st_bookmark *result= NULL;
-  uint namelen, length, pluginlen= 0;
+  size_t namelen, length, pluginlen= 0;
   char *varname, *p;
 
   if (!(flags & PLUGIN_VAR_THDLOCAL))
@@ -2941,7 +2942,7 @@ static size_t var_storage_size(int flags)
 static st_bookmark *register_var(const char *plugin, const char *name,
                                  int flags)
 {
-  uint length= strlen(plugin) + strlen(name) + 3, size, offset, new_size;
+  size_t length= strlen(plugin) + strlen(name) + 3, size, offset, new_size;
   st_bookmark *result;
   char *varname, *p;
 
@@ -2960,7 +2961,7 @@ static st_bookmark *register_var(const char *plugin, const char *name,
                                       sizeof(struct st_bookmark) + length-1);
     varname[0]= plugin_var_bookmark_key(flags);
     memcpy(result->key, varname, length);
-    result->name_len= length - 2;
+    result->name_len= (uint)(length - 2);
     result->offset= -1;
 
     DBUG_ASSERT(size && !(size & (size-1))); /* must be power of 2 */
@@ -2993,10 +2994,10 @@ static st_bookmark *register_var(const char *plugin, const char *name,
       global_variables_dynamic_size= new_size;
     }
 
-    global_system_variables.dynamic_variables_head= offset;
-    max_system_variables.dynamic_variables_head= offset;
-    global_system_variables.dynamic_variables_size= offset + size;
-    max_system_variables.dynamic_variables_size= offset + size;
+    global_system_variables.dynamic_variables_head= (uint)offset;
+    max_system_variables.dynamic_variables_head= (uint)offset;
+    global_system_variables.dynamic_variables_size= (uint)(offset + size);
+    max_system_variables.dynamic_variables_size= (uint)(offset + size);
     global_system_variables.dynamic_variables_version++;
     max_system_variables.dynamic_variables_version++;
 
@@ -3694,8 +3695,8 @@ static int construct_options(MEM_ROOT *mem_root, struct st_plugin_int *tmp,
 {
   const char *plugin_name= tmp->plugin->name;
   const LEX_CSTRING plugin_dash = { STRING_WITH_LEN("plugin-") };
-  uint plugin_name_len= strlen(plugin_name);
-  uint optnamelen;
+  size_t plugin_name_len= strlen(plugin_name);
+  size_t optnamelen;
   const int max_comment_len= 180;
   char *comment= (char *) alloc_root(mem_root, max_comment_len + 1);
   char *optname;
@@ -4020,7 +4021,7 @@ static int test_plugin_options(MEM_ROOT *tmp_root, struct st_plugin_int *tmp,
   my_option *opts= NULL;
   int error= 1;
   struct st_bookmark *var;
-  uint len=0, count= EXTRA_OPTIONS;
+  size_t len=0, count= EXTRA_OPTIONS;
   st_ptr_backup *tmp_backup= 0;
   DBUG_ENTER("test_plugin_options");
   DBUG_ASSERT(tmp->plugin && tmp->name.str);
diff --git a/sql/sql_prepare.h b/sql/sql_prepare.h
index 203b37b3b26..4eb50b9b9d8 100644
--- a/sql/sql_prepare.h
+++ b/sql/sql_prepare.h
@@ -215,21 +215,6 @@ public:
   bool execute_direct(Server_runnable *server_runnable);
 
   /**
-    Get the number of result set fields.
-
-    This method is valid only if we have a result:
-    execute_direct() has been called. Otherwise
-    the returned value is undefined.
-
-    @sa Documentation for C API function
-    mysql_field_count()
-  */
-  ulong get_field_count() const
-  {
-    return m_current_rset ? m_current_rset->get_field_count() : 0;
-  }
-
-  /**
     Get the number of affected (deleted, updated)
     rows for the current statement. Can be
     used for statements with get_field_count() == 0.
diff --git a/sql/sql_profile.cc b/sql/sql_profile.cc
index c1a13ebd210..13f03fed5f3 100644
--- a/sql/sql_profile.cc
+++ b/sql/sql_profile.cc
@@ -284,11 +284,10 @@ QUERY_PROFILE::~QUERY_PROFILE()
 /**
   @todo  Provide a way to include the full text, as in  SHOW PROCESSLIST.
 */
-void QUERY_PROFILE::set_query_source(char *query_source_arg,
-                                     uint query_length_arg)
+void QUERY_PROFILE::set_query_source(char *query_source_arg, size_t query_length_arg)
 {
   /* Truncate to avoid DoS attacks. */
-  uint length= MY_MIN(MAX_QUERY_LENGTH, query_length_arg);
+  size_t length= MY_MIN(MAX_QUERY_LENGTH, query_length_arg);
 
   DBUG_ASSERT(query_source == NULL); /* we don't leak memory */
   if (query_source_arg != NULL)
diff --git a/sql/sql_profile.h b/sql/sql_profile.h
index c96828fc678..cb553d2f757 100644
--- a/sql/sql_profile.h
+++ b/sql/sql_profile.h
@@ -227,7 +227,7 @@ private:
   QUERY_PROFILE(PROFILING *profiling_arg, const char *status_arg);
   ~QUERY_PROFILE();
 
-  void set_query_source(char *query_source_arg, uint query_length_arg);
+  void set_query_source(char *query_source_arg, size_t query_length_arg);
 
   /* Add a profile status change to the current profile. */
   void new_status(const char *status_arg,
@@ -275,7 +275,7 @@ public:
 
     This must be called exactly once per descrete statement.
   */
-  void set_query_source(char *query_source_arg, uint query_length_arg)
+  void set_query_source(char *query_source_arg, size_t query_length_arg)
   {
     if (unlikely(current))
       current->set_query_source(query_source_arg, query_length_arg);
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index 2bca32ddcda..e1d1190e58f 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -828,8 +828,8 @@ static int send_heartbeat_event(binlog_send_info *info,
 
   char* p= coord->file_name + dirname_length(coord->file_name);
 
-  uint ident_len = strlen(p);
-  ulong event_len = ident_len + LOG_EVENT_HEADER_LEN +
+  size_t ident_len = strlen(p);
+  size_t event_len = ident_len + LOG_EVENT_HEADER_LEN +
     (do_checksum ? BINLOG_CHECKSUM_LEN : 0);
   int4store(header + SERVER_ID_OFFSET, global_system_variables.server_id);
   int4store(header + EVENT_LEN_OFFSET, event_len);
@@ -3409,7 +3409,7 @@ static bool get_string_parameter(char *to, const char *from, size_t length,
   if (from)                                     // Empty paramaters allowed
   {
     size_t from_length= strlen(from);
-    uint from_numchars= cs->cset->numchars(cs, from, from + from_length);
+    size_t from_numchars= cs->cset->numchars(cs, from, from + from_length);
     if (from_numchars > length / cs->mbmaxlen)
     {
       my_error(ER_WRONG_STRING_LENGTH, MYF(0), from, name,
@@ -4124,7 +4124,7 @@ bool show_binlog_info(THD* thd)
   {
     LOG_INFO li;
     mysql_bin_log.get_current_log(&li);
-    int dir_len = dirname_length(li.log_file_name);
+    size_t dir_len = dirname_length(li.log_file_name);
     protocol->store(li.log_file_name + dir_len, &my_charset_bin);
     protocol->store((ulonglong) li.pos);
     protocol->store(binlog_filter->get_do_db());
@@ -4166,8 +4166,8 @@ bool show_binlogs(THD* thd)
   File file;
   char fname[FN_REFLEN];
   List<Item> field_list;
-  uint length;
-  int cur_dir_len;
+  size_t length;
+  size_t cur_dir_len;
   Protocol *protocol= thd->protocol;
   DBUG_ENTER("show_binlogs");
 
@@ -4197,7 +4197,7 @@ bool show_binlogs(THD* thd)
   /* The file ends with EOF or empty line */
   while ((length=my_b_gets(index_file, fname, sizeof(fname))) > 1)
   {
-    int dir_len;
+    size_t dir_len;
     ulonglong file_length= 0;                   // Length if open fails
     fname[--length] = '\0';                     // remove the newline
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 2c1452e8096..9cef3027e78 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -24972,7 +24972,7 @@ bool JOIN_TAB::save_explain_data(Explain_table_access *eta,
   if (table->derived_select_number)
   {
     /* Derived table name generation */
-    int len= my_snprintf(table_name_buffer, sizeof(table_name_buffer)-1,
+    size_t len= my_snprintf(table_name_buffer, sizeof(table_name_buffer)-1,
                          "<derived%u>",
                          table->derived_select_number);
     eta->table_name.copy(table_name_buffer, len, cs);
@@ -24981,7 +24981,7 @@ bool JOIN_TAB::save_explain_data(Explain_table_access *eta,
   {
     JOIN_TAB *ctab= bush_children->start;
     /* table */
-    int len= my_snprintf(table_name_buffer, 
+    size_t len= my_snprintf(table_name_buffer, 
                          sizeof(table_name_buffer)-1,
                          "<subquery%d>", 
                          ctab->emb_sj_nest->sj_subq_pred->get_identifier());
@@ -25330,7 +25330,7 @@ bool JOIN_TAB::save_explain_data(Explain_table_access *eta,
         {
           char namebuf[NAME_LEN];
           /* Derived table name generation */
-          int len= my_snprintf(namebuf, sizeof(namebuf)-1,
+          size_t len= my_snprintf(namebuf, sizeof(namebuf)-1,
                                "<derived%u>",
                                prev_table->derived_select_number);
           eta->firstmatch_table_name.append(namebuf, len);
diff --git a/sql/sql_servers.cc b/sql/sql_servers.cc
index 4a0addc7b07..353d1f551a5 100644
--- a/sql/sql_servers.cc
+++ b/sql/sql_servers.cc
@@ -85,7 +85,7 @@ static uchar *servers_cache_get_key(FOREIGN_SERVER *server, size_t *length,
 			       my_bool not_used __attribute__((unused)))
 {
   DBUG_ENTER("servers_cache_get_key");
-  DBUG_PRINT("info", ("server_name_length %d server_name %s",
+  DBUG_PRINT("info", ("server_name_length %zd server_name %s",
                       server->server_name_length,
                       server->server_name));
 
@@ -433,7 +433,7 @@ insert_server_record_into_cache(FOREIGN_SERVER *server)
     We succeded in insertion of the server to the table, now insert
     the server to the cache
   */
-  DBUG_PRINT("info", ("inserting server %s at %p, length %d",
+  DBUG_PRINT("info", ("inserting server %s at %p, length %zd",
                         server->server_name, server,
                         server->server_name_length));
   if (my_hash_insert(&servers_cache, (uchar*) server))
@@ -689,7 +689,7 @@ delete_server_record_in_cache(LEX_SERVER_OPTIONS *server_options)
     We succeded in deletion of the server to the table, now delete
     the server from the cache
   */
-  DBUG_PRINT("info",("deleting server %s length %d",
+  DBUG_PRINT("info",("deleting server %s length %zd",
                      server->server_name,
                      server->server_name_length));
 
diff --git a/sql/sql_servers.h b/sql/sql_servers.h
index 1cb05416c63..b2fa40cef27 100644
--- a/sql/sql_servers.h
+++ b/sql/sql_servers.h
@@ -27,7 +27,7 @@ typedef struct st_federated_server
 {
   const char *server_name;
   long port;
-  uint server_name_length;
+  size_t server_name_length;
   const char *db, *scheme, *username, *password, *socket, *owner, *host, *sport;
 } FOREIGN_SERVER;
 
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 4fc0b65b774..2e06b912891 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -174,7 +174,7 @@ static bool is_show_command(THD *thd)
 
 static int make_version_string(char *buf, int buf_length, uint version)
 {
-  return my_snprintf(buf, buf_length, "%d.%d", version>>8,version&0xff);
+  return (int)my_snprintf(buf, buf_length, "%d.%d", version>>8,version&0xff);
 }
 
 
@@ -1627,7 +1627,7 @@ static const char *require_quotes(const char *name, uint name_length)
 */
 
 bool
-append_identifier(THD *thd, String *packet, const char *name, uint length)
+append_identifier(THD *thd, String *packet, const char *name, size_t length)
 {
   const char *name_end;
   char quote_char;
@@ -1706,11 +1706,11 @@ append_identifier(THD *thd, String *packet, const char *name, uint length)
     #	  Quote character
 */
 
-int get_quote_char_for_identifier(THD *thd, const char *name, uint length)
+int get_quote_char_for_identifier(THD *thd, const char *name, size_t length)
 {
   if (length &&
-      !is_keyword(name,length) &&
-      !require_quotes(name, length) &&
+      !is_keyword(name,(uint)length) &&
+      !require_quotes(name, (uint)length) &&
       !(thd->variables.option_bits & OPTION_QUOTE_SHOW_CREATE))
     return EOF;
   if (thd->variables.sql_mode & MODE_ANSI_QUOTES)
@@ -1726,7 +1726,7 @@ static void append_directory(THD *thd, String *packet, const char *dir_type,
 {
   if (filename && !(thd->variables.sql_mode & MODE_NO_DIR_IN_CREATE))
   {
-    uint length= dirname_length(filename);
+    size_t length= dirname_length(filename);
     packet->append(' ');
     packet->append(dir_type);
     packet->append(STRING_WITH_LEN(" DIRECTORY='"));
@@ -6736,7 +6736,7 @@ static int get_schema_views_record(THD *thd, TABLE_LIST *tables,
 static bool
 store_constraints(THD *thd, TABLE *table, const LEX_CSTRING *db_name,
                   const LEX_CSTRING *table_name, const char *key_name,
-                  uint key_len, const char *con_type, uint con_len)
+                  size_t key_len, const char *con_type, size_t con_len)
 {
   CHARSET_INFO *cs= system_charset_info;
   restore_record(table, s->default_values);
@@ -6932,7 +6932,7 @@ ret:
 static void
 store_key_column_usage(TABLE *table, const LEX_CSTRING *db_name,
                        const LEX_CSTRING *table_name, const char *key_name,
-                       uint key_len, const char *con_type, uint con_len,
+                       size_t key_len, const char *con_type, size_t con_len,
                        longlong idx)
 {
   CHARSET_INFO *cs= system_charset_info;
@@ -7965,7 +7965,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
 
   for (; fields_info->field_name; fields_info++)
   {
-    uint field_name_length= strlen(fields_info->field_name);
+    size_t field_name_length= strlen(fields_info->field_name);
     switch (fields_info->field_type) {
     case MYSQL_TYPE_TINY:
     case MYSQL_TYPE_LONG:
@@ -7985,14 +7985,14 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
     case MYSQL_TYPE_DATE:
       if (!(item=new (mem_root)
             Item_return_date_time(thd, fields_info->field_name,
-                                  field_name_length,
+                                  (uint)field_name_length,
                                   fields_info->field_type)))
         DBUG_RETURN(0);
       break;
     case MYSQL_TYPE_TIME:
       if (!(item=new (mem_root)
             Item_return_date_time(thd, fields_info->field_name,
-                                  field_name_length,
+                                  (uint)field_name_length,
                                   fields_info->field_type)))
         DBUG_RETURN(0);
       break;
@@ -8000,7 +8000,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
     case MYSQL_TYPE_DATETIME:
       if (!(item=new (mem_root)
             Item_return_date_time(thd, fields_info->field_name,
-                                  field_name_length,
+                                  (uint)field_name_length,
                                   fields_info->field_type,
                                   fields_info->field_length)))
         DBUG_RETURN(0);
@@ -8721,7 +8721,7 @@ int hton_fill_schema_table(THD *thd, TABLE_LIST *tables, COND *cond)
 
 static
 int store_key_cache_table_record(THD *thd, TABLE *table,
-                                 const char *name, uint name_length,
+                                 const char *name, size_t name_length,
                                  KEY_CACHE *key_cache,
                                  uint partitions, uint partition_no)
 {
@@ -9816,7 +9816,7 @@ static bool show_create_trigger_impl(THD *thd, Trigger *trigger)
   fields.push_back(new (mem_root) Item_empty_string(thd, "Trigger", NAME_LEN),
                    mem_root);
   fields.push_back(new (mem_root)
-                   Item_empty_string(thd, "sql_mode", trg_sql_mode_str.length),
+                   Item_empty_string(thd, "sql_mode", (uint)trg_sql_mode_str.length),
                    mem_root);
 
   {
@@ -9827,7 +9827,7 @@ static bool show_create_trigger_impl(THD *thd, Trigger *trigger)
 
     Item_empty_string *stmt_fld=
       new (mem_root) Item_empty_string(thd, "SQL Original Statement",
-                                       MY_MAX(trg_sql_original_stmt.length,
+                                       (uint)MY_MAX(trg_sql_original_stmt.length,
                                               1024));
 
     stmt_fld->maybe_null= TRUE;
diff --git a/sql/sql_show.h b/sql/sql_show.h
index 2715e0405bd..f6d5d4d2c3c 100644
--- a/sql/sql_show.h
+++ b/sql/sql_show.h
@@ -82,8 +82,7 @@ int show_create_table(THD *thd, TABLE_LIST *table_list, String *packet,
 
 int copy_event_to_schema_table(THD *thd, TABLE *sch_table, TABLE *event_table);
 
-bool append_identifier(THD *thd, String *packet, const char *name,
-		       uint length);
+bool append_identifier(THD *thd, String *packet, const char *name, size_t length);
 static inline bool append_identifier(THD *thd, String *packet, const LEX_CSTRING *name)
 {
   return append_identifier(thd, packet, name->str, name->length);
@@ -143,7 +142,7 @@ const char* get_one_variable(THD *thd, const SHOW_VAR *variable,
                              size_t *length);
 
 /* These functions were under INNODB_COMPATIBILITY_HOOKS */
-int get_quote_char_for_identifier(THD *thd, const char *name, uint length);
+int get_quote_char_for_identifier(THD *thd, const char *name, size_t length);
 THD *find_thread_by_id(longlong id, bool query_id= false);
 
 class select_result_explain_buffer;
diff --git a/sql/sql_string.cc b/sql/sql_string.cc
index d0d0e35000d..390abe36b6c 100644
--- a/sql/sql_string.cc
+++ b/sql/sql_string.cc
@@ -240,8 +240,8 @@ bool String::copy(const char *str,size_t arg_length, CHARSET_INFO *cs)
 {
   if (alloc(arg_length))
     return TRUE;
-  DBUG_ASSERT(arg_length < UINT_MAX32);
-  if ((str_length=arg_length))
+  DBUG_ASSERT(arg_length <= UINT_MAX32);
+  if ((str_length=(uint32)arg_length))
     memcpy(Ptr,str,arg_length);
   Ptr[arg_length]=0;
   str_charset=cs;
@@ -271,7 +271,7 @@ bool String::copy(const char *str,size_t arg_length, CHARSET_INFO *cs)
   character_set_results is NULL.
 */
 
-bool String::needs_conversion(uint32 arg_length,
+bool String::needs_conversion(size_t arg_length,
 			      CHARSET_INFO *from_cs,
 			      CHARSET_INFO *to_cs,
 			      uint32 *offset)
@@ -282,7 +282,7 @@ bool String::needs_conversion(uint32 arg_length,
       (to_cs == from_cs) ||
       my_charset_same(from_cs, to_cs) ||
       ((from_cs == &my_charset_bin) &&
-       (!(*offset=(arg_length % to_cs->mbminlen)))))
+       (!(*offset=(uint32)(arg_length % to_cs->mbminlen)))))
     return FALSE;
   return TRUE;
 }
@@ -300,7 +300,7 @@ bool String::needs_conversion(uint32 arg_length,
 
   @return conversion needed
 */
-bool String::needs_conversion_on_storage(uint32 arg_length,
+bool String::needs_conversion_on_storage(size_t arg_length,
                                          CHARSET_INFO *cs_from,
                                          CHARSET_INFO *cs_to)
 {
@@ -349,14 +349,14 @@ bool String::needs_conversion_on_storage(uint32 arg_length,
     1  error
 */
 
-bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
+bool String::copy_aligned(const char *str, size_t arg_length, size_t offset,
 			  CHARSET_INFO *cs)
 {
   /* How many bytes are in incomplete character */
   offset= cs->mbminlen - offset; /* How many zeros we should prepend */
   DBUG_ASSERT(offset && offset != cs->mbminlen);
 
-  uint32 aligned_length= arg_length + offset;
+  size_t aligned_length= arg_length + offset;
   if (alloc(aligned_length))
     return TRUE;
   
@@ -369,17 +369,17 @@ bool String::copy_aligned(const char *str,uint32 arg_length, uint32 offset,
   memcpy(Ptr + offset, str, arg_length);
   Ptr[aligned_length]=0;
   /* str_length is always >= 0 as arg_length is != 0 */
-  str_length= aligned_length;
+  str_length= (uint32)aligned_length;
   str_charset= cs;
   return FALSE;
 }
 
 
-bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
+bool String::set_or_copy_aligned(const char *str, size_t arg_length,
 				 CHARSET_INFO *cs)
 {
   /* How many bytes are in incomplete character */
-  uint32 offset= (arg_length % cs->mbminlen); 
+  size_t offset= (arg_length % cs->mbminlen); 
   
   if (!offset) /* All characters are complete, just copy */
   {
@@ -400,7 +400,7 @@ bool String::set_or_copy_aligned(const char *str,uint32 arg_length,
 
 */
 
-bool String::copy(const char *str, uint32 arg_length,
+bool String::copy(const char *str, size_t arg_length,
 		  CHARSET_INFO *from_cs, CHARSET_INFO *to_cs, uint *errors)
 {
   uint32 offset;
@@ -417,7 +417,7 @@ bool String::copy(const char *str, uint32 arg_length,
     *errors= 0;
     return copy_aligned(str, arg_length, offset, to_cs);
   }
-  uint32 new_length= to_cs->mbmaxlen*arg_length;
+  size_t new_length= to_cs->mbmaxlen*arg_length;
   if (alloc(new_length))
     return TRUE;
   str_length=copy_and_convert((char*) Ptr, new_length, to_cs,
@@ -446,7 +446,7 @@ bool String::copy(const char *str, uint32 arg_length,
 
 */
 
-bool String::set_ascii(const char *str, uint32 arg_length)
+bool String::set_ascii(const char *str, size_t arg_length)
 {
   if (str_charset->mbminlen == 1)
   {
@@ -454,7 +454,7 @@ bool String::set_ascii(const char *str, uint32 arg_length)
     return 0;
   }
   uint dummy_errors;
-  return copy(str, arg_length, &my_charset_latin1, str_charset, &dummy_errors);
+  return copy(str, (uint32)arg_length, &my_charset_latin1, str_charset, &dummy_errors);
 }
 
 
@@ -563,13 +563,13 @@ bool String::append_ulonglong(ulonglong val)
   with character set recoding
 */
 
-bool String::append(const char *s, uint arg_length, CHARSET_INFO *cs)
+bool String::append(const char *s, size_t arg_length, CHARSET_INFO *cs)
 {
   uint32 offset;
   
-  if (needs_conversion(arg_length, cs, str_charset, &offset))
+  if (needs_conversion((uint32)arg_length, cs, str_charset, &offset))
   {
-    uint32 add_length;
+    size_t add_length;
     if ((cs == &my_charset_bin) && offset)
     {
       DBUG_ASSERT(str_charset->mbminlen > offset);
@@ -579,7 +579,7 @@ bool String::append(const char *s, uint arg_length, CHARSET_INFO *cs)
         return TRUE;
       bzero((char*) Ptr + str_length, offset);
       memcpy(Ptr + str_length + offset, s, arg_length);
-      str_length+= add_length;
+      str_length+= (uint32)add_length;
       return FALSE;
     }
 
@@ -587,15 +587,15 @@ bool String::append(const char *s, uint arg_length, CHARSET_INFO *cs)
     uint dummy_errors;
     if (realloc_with_extra_if_needed(str_length + add_length)) 
       return TRUE;
-    str_length+= copy_and_convert(Ptr+str_length, add_length, str_charset,
-				  s, arg_length, cs, &dummy_errors);
+    str_length+= copy_and_convert(Ptr+str_length, (uint32)add_length, str_charset,
+				  s, (uint32)arg_length, cs, &dummy_errors);
   }
   else
   {
     if (realloc_with_extra_if_needed(str_length + arg_length)) 
       return TRUE;
     memcpy(Ptr + str_length, s, arg_length);
-    str_length+= arg_length;
+    str_length+= (uint32)arg_length;
   }
   return FALSE;
 }
@@ -760,7 +760,7 @@ bool String::replace(uint32 offset,uint32 arg_length,
 
 
 // added by Holyfoot for "geometry" needs
-int String::reserve(uint32 space_needed, uint32 grow_by)
+int String::reserve(size_t space_needed, size_t grow_by)
 {
   if (Alloced_length < str_length + space_needed)
   {
@@ -770,10 +770,10 @@ int String::reserve(uint32 space_needed, uint32 grow_by)
   return FALSE;
 }
 
-void String::qs_append(const char *str, uint32 len)
+void String::qs_append(const char *str, size_t len)
 {
   memcpy(Ptr + str_length, str, len + 1);
-  str_length += len;
+  str_length += (uint32)len;
 }
 
 void String::qs_append(double d)
@@ -1072,10 +1072,9 @@ my_copy_with_hex_escaping(CHARSET_INFO *cs,
 */
 uint
 String_copier::well_formed_copy(CHARSET_INFO *to_cs,
-                                char *to, uint to_length,
+                                char *to, size_t to_length,
                                 CHARSET_INFO *from_cs,
-                                const char *from, uint from_length,
-                                uint nchars)
+                                const char *from, size_t from_length, size_t nchars)
 {
   if ((to_cs == &my_charset_bin) || 
       (from_cs == &my_charset_bin) ||
@@ -1098,7 +1097,7 @@ String_copier::well_formed_copy(CHARSET_INFO *to_cs,
   Does not add the enclosing quotes, this is left up to caller.
 */
 #define APPEND(X)   if (append(X)) return 1; else break
-bool String::append_for_single_quote(const char *st, uint len)
+bool String::append_for_single_quote(const char *st, size_t len)
 {
   const char *end= st+len;
   for (; st < end; st++)
diff --git a/sql/sql_string.h b/sql/sql_string.h
index fda90f9543e..25940196fda 100644
--- a/sql/sql_string.h
+++ b/sql/sql_string.h
@@ -35,12 +35,12 @@ typedef struct st_mem_root MEM_ROOT;
 #include "pack.h"
 int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
 String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
-inline uint32 copy_and_convert(char *to, uint32 to_length,
+inline uint32 copy_and_convert(char *to, size_t to_length,
                                CHARSET_INFO *to_cs,
-                               const char *from, uint32 from_length,
+                               const char *from, size_t from_length,
                                CHARSET_INFO *from_cs, uint *errors)
 {
-  return my_convert(to, to_length, to_cs, from, from_length, from_cs, errors);
+  return my_convert(to, (uint)to_length, to_cs, from, (uint)from_length, from_cs, errors);
 }
 
 
@@ -97,9 +97,8 @@ public:
     Convert a string between character sets.
     "dstcs" and "srccs" cannot be &my_charset_bin.
   */
-  size_t convert_fix(CHARSET_INFO *dstcs, char *dst, uint dst_length,
-                     CHARSET_INFO *srccs, const char *src, uint src_length,
-                     uint nchars)
+  size_t convert_fix(CHARSET_INFO *dstcs, char *dst, size_t dst_length,
+                     CHARSET_INFO *srccs, const char *src, size_t src_length, size_t nchars)
   {
     return my_convert_fix(dstcs, dst, dst_length,
                           srccs, src, src_length, nchars, this, this);
@@ -107,13 +106,11 @@ public:
   /*
      Copy a string. Fix bad bytes/characters to '?'.
   */
-  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, uint to_length,
-                        CHARSET_INFO *from_cs, const char *from,
-                        uint from_length, uint nchars);
+  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
+                        CHARSET_INFO *from_cs, const char *from, size_t from_length, size_t nchars);
   // Same as above, but without the "nchars" limit.
-  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, uint to_length,
-                        CHARSET_INFO *from_cs, const char *from,
-                        uint from_length)
+  uint well_formed_copy(CHARSET_INFO *to_cs, char *to, size_t to_length,
+                        CHARSET_INFO *from_cs, const char *from, size_t from_length)
   {
     return well_formed_copy(to_cs, to, to_length,
                             from_cs, from, from_length,
@@ -142,7 +139,7 @@ public:
     alloced= thread_specific= 0; 
     str_charset= &my_charset_bin; 
   }
-  String(uint32 length_arg)
+  String(size_t length_arg)
   { 
     alloced= thread_specific= 0;
     Alloced_length= extra_alloc= 0; (void) real_alloc(length_arg); 
@@ -160,15 +157,15 @@ public:
     contructors need the size of memory for STR to be at least LEN+1 (to make
     room for zero termination).
   */
-  String(const char *str,uint32 len, CHARSET_INFO *cs)
+  String(const char *str,size_t len, CHARSET_INFO *cs)
   { 
-    Ptr=(char*) str; str_length=len; Alloced_length= extra_alloc=0;
+    Ptr=(char*) str; str_length=(uint32)len; Alloced_length= extra_alloc=0;
     alloced= thread_specific= 0;
     str_charset=cs;
   }
-  String(char *str,uint32 len, CHARSET_INFO *cs)
+  String(char *str,size_t len, CHARSET_INFO *cs)
   { 
-    Ptr=(char*) str; Alloced_length=str_length=len; extra_alloc= 0;
+    Ptr=(char*) str; Alloced_length=str_length=(uint32)len; extra_alloc= 0;
     alloced= thread_specific= 0;
     str_charset=cs;
   }
@@ -180,7 +177,7 @@ public:
     str_charset=str.str_charset;
   }
   static void *operator new(size_t size, MEM_ROOT *mem_root) throw ()
-  { return (void*) alloc_root(mem_root, (uint) size); }
+  { return (void*) alloc_root(mem_root, size); }
   static void *operator new[](size_t size, MEM_ROOT *mem_root) throw ()
   { return alloc_root(mem_root, size); }
   static void operator delete(void *ptr_arg, size_t size)
@@ -209,9 +206,9 @@ public:
   inline uint32 length() const { return str_length;}
   inline uint32 alloced_length() const { return Alloced_length;}
   inline uint32 extra_allocation() const { return extra_alloc;}
-  inline char& operator [] (uint32 i) const { return Ptr[i]; }
-  inline void length(uint32 len) { str_length=len ; }
-  inline void extra_allocation(uint32 len) { extra_alloc= len; }
+  inline char& operator [] (size_t i) const { return Ptr[i]; }
+  inline void length(size_t len) { str_length=(uint32)len ; }
+  inline void extra_allocation(size_t len) { extra_alloc= (uint32)len; }
   inline bool is_empty() const { return (str_length == 0); }
   inline void mark_as_const() { Alloced_length= 0;}
   inline const char *ptr() const { return Ptr; }
@@ -250,13 +247,13 @@ public:
     return skr;
   }
 
-  void set(String &str,uint32 offset,uint32 arg_length)
+  void set(String &str,size_t offset,size_t arg_length)
   {
     DBUG_ASSERT(&str != this);
     free();
-    Ptr=(char*) str.ptr()+offset; str_length=arg_length;
+    Ptr=(char*) str.ptr()+offset; str_length=(uint32)arg_length;
     if (str.Alloced_length)
-      Alloced_length=str.Alloced_length-offset;
+      Alloced_length=(uint32)(str.Alloced_length-offset);
     str_charset=str.str_charset;
   }
 
@@ -269,24 +266,24 @@ public:
      @param cs Character set to use for interpreting string data.
      @note The new buffer will not be null terminated.
   */
-  inline void set(char *str,uint32 arg_length, CHARSET_INFO *cs)
+  inline void set(char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     free();
-    Ptr=(char*) str; str_length=Alloced_length=arg_length;
+    Ptr=(char*) str; str_length=Alloced_length=(uint32)arg_length;
     str_charset=cs;
   }
-  inline void set(const char *str,uint32 arg_length, CHARSET_INFO *cs)
+  inline void set(const char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     free();
-    Ptr=(char*) str; str_length=arg_length;
+    Ptr=(char*) str; str_length=(uint32)arg_length;
     str_charset=cs;
   }
-  bool set_ascii(const char *str, uint32 arg_length);
-  inline void set_quick(char *str,uint32 arg_length, CHARSET_INFO *cs)
+  bool set_ascii(const char *str, size_t arg_length);
+  inline void set_quick(char *str,size_t arg_length, CHARSET_INFO *cs)
   {
     if (!alloced)
     {
-      Ptr=(char*) str; str_length=Alloced_length=arg_length;
+      Ptr=(char*) str; str_length=Alloced_length=(uint32)arg_length;
     }
     str_charset=cs;
   }
@@ -303,13 +300,13 @@ public:
   bool set_hex(const char *str, uint32 len);
 
   /* Take over handling of buffer from some other object */
-  void reset(char *ptr_arg, uint32 length_arg, uint32 alloced_length_arg,
+  void reset(char *ptr_arg, size_t length_arg, size_t alloced_length_arg,
              CHARSET_INFO *cs)
   { 
     free();
     Ptr= ptr_arg;
-    str_length= length_arg;
-    Alloced_length= alloced_length_arg;
+    str_length= (uint32)length_arg;
+    Alloced_length= (uint32)alloced_length_arg;
     str_charset= cs;
     alloced= ptr_arg != 0;
   }
@@ -438,29 +435,29 @@ public:
   bool copy();					// Alloc string if not alloced
   bool copy(const String &s);			// Allocate new string
   bool copy(const char *s,size_t arg_length, CHARSET_INFO *cs);	// Allocate new string
-  static bool needs_conversion(uint32 arg_length,
+  static bool needs_conversion(size_t arg_length,
   			       CHARSET_INFO *cs_from, CHARSET_INFO *cs_to,
 			       uint32 *offset);
-  static bool needs_conversion_on_storage(uint32 arg_length,
+  static bool needs_conversion_on_storage(size_t arg_length,
                                           CHARSET_INFO *cs_from,
                                           CHARSET_INFO *cs_to);
-  bool copy_aligned(const char *s, uint32 arg_length, uint32 offset,
+  bool copy_aligned(const char *s, size_t arg_length, size_t offset,
 		    CHARSET_INFO *cs);
-  bool set_or_copy_aligned(const char *s, uint32 arg_length, CHARSET_INFO *cs);
-  bool copy(const char*s,uint32 arg_length, CHARSET_INFO *csfrom,
+  bool set_or_copy_aligned(const char *s, size_t arg_length, CHARSET_INFO *cs);
+  bool copy(const char*s, size_t arg_length, CHARSET_INFO *csfrom,
 	    CHARSET_INFO *csto, uint *errors);
   bool copy(const String *str, CHARSET_INFO *tocs, uint *errors)
   {
     return copy(str->ptr(), str->length(), str->charset(), tocs, errors);
   }
   bool copy(CHARSET_INFO *tocs,
-            CHARSET_INFO *fromcs, const char *src, uint32 src_length,
-            uint32 nchars, String_copier *copier)
+            CHARSET_INFO *fromcs, const char *src, size_t src_length,
+            size_t nchars, String_copier *copier)
   {
     if (alloc(tocs->mbmaxlen * src_length))
       return true;
     str_length= copier->well_formed_copy(tocs, Ptr, Alloced_length,
-                                         fromcs, src, src_length, nchars);
+                                         fromcs, src, (uint)src_length, (uint)nchars);
     str_charset= tocs;
     return false;
   }
@@ -490,7 +487,7 @@ public:
     return append(ls->str, (uint32) ls->length);
   }
   bool append(const char *s, size_t size);
-  bool append(const char *s, uint arg_length, CHARSET_INFO *cs);
+  bool append(const char *s, size_t arg_length, CHARSET_INFO *cs);
   bool append_ulonglong(ulonglong val);
   bool append_longlong(longlong val);
   bool append(IO_CACHE* file, uint32 arg_length);
@@ -538,11 +535,11 @@ public:
   uint32 numchars() const;
   int charpos(longlong i,uint32 offset=0);
 
-  int reserve(uint32 space_needed)
+  int reserve(size_t space_needed)
   {
     return realloc(str_length + space_needed);
   }
-  int reserve(uint32 space_needed, uint32 grow_by);
+  int reserve(size_t space_needed, size_t grow_by);
 
   /*
     The following append operations do NOT check alloced memory
@@ -601,9 +598,9 @@ public:
     DBUG_ASSERT(ls->length < UINT_MAX32 &&
                 ((ls->length == 0 && !ls->str) ||
                  ls->length == strlen(ls->str)));
-    qs_append(ls->str, ls->length);
+    qs_append(ls->str, (uint32)ls->length);
   }
-  void qs_append(const char *str, uint32 len);
+  void qs_append(const char *str, size_t len);
   void qs_append_hex(const char *str, uint32 len);
   void qs_append(double d);
   void qs_append(double *d);
@@ -664,7 +661,7 @@ public:
       print_with_conversion(to, cs);
   }
 
-  bool append_for_single_quote(const char *st, uint len);
+  bool append_for_single_quote(const char *st, size_t len);
   bool append_for_single_quote(const String *s)
   {
     return append_for_single_quote(s->ptr(), s->length());
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index f96b9c40930..fb1f3cfb792 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -95,7 +95,7 @@ static uint blob_length_by_type(enum_field_types type);
   @param name_len     Length of the name, in bytes
 */
 static char* add_identifier(THD* thd, char *to_p, const char * end_p,
-                            const char* name, uint name_len)
+                            const char* name, size_t name_len)
 {
   uint res;
   uint errors;
@@ -215,13 +215,13 @@ uint explain_filename(THD* thd,
   char *to_p= to;
   char *end_p= to_p + to_length;
   const char *db_name= NULL;
-  int  db_name_len= 0;
+  size_t  db_name_len= 0;
   const char *table_name;
-  int  table_name_len= 0;
+  size_t  table_name_len= 0;
   const char *part_name= NULL;
-  int  part_name_len= 0;
+  size_t  part_name_len= 0;
   const char *subpart_name= NULL;
-  int  subpart_name_len= 0;
+  size_t  subpart_name_len= 0;
   uint part_type= NORMAL_PART_NAME;
 
   const char *tmp_p;
@@ -381,7 +381,7 @@ uint explain_filename(THD* thd,
     Table name length.
 */
 
-uint filename_to_tablename(const char *from, char *to, uint to_length, 
+uint filename_to_tablename(const char *from, char *to, size_t to_length, 
                            bool stay_quiet)
 {
   uint errors;
@@ -400,7 +400,7 @@ uint filename_to_tablename(const char *from, char *to, uint to_length,
   }
 
   DBUG_PRINT("exit", ("to '%s'", to));
-  DBUG_RETURN(res);
+  DBUG_RETURN((uint)res);
 }
 
 
@@ -436,7 +436,7 @@ bool check_mysql50_prefix(const char *name)
     non-0  result string length
 */
 
-uint check_n_cut_mysql50_prefix(const char *from, char *to, uint to_length)
+uint check_n_cut_mysql50_prefix(const char *from, char *to, size_t to_length)
 {
   if (check_mysql50_prefix(from))
     return (uint) (strmake(to, from + MYSQL50_TABLE_NAME_PREFIX_LENGTH,
@@ -465,7 +465,7 @@ static bool check_if_frm_exists(char *path, const char *db, const char *table)
     File name length.
 */
 
-uint tablename_to_filename(const char *from, char *to, uint to_length)
+uint tablename_to_filename(const char *from, char *to, size_t to_length)
 {
   uint errors, length;
   DBUG_ENTER("tablename_to_filename");
@@ -608,7 +608,7 @@ uint build_tmptable_filename(THD* thd, char *buff, size_t bufflen)
 
   size_t length= unpack_filename(buff, buff);
   DBUG_PRINT("exit", ("buff: '%s'", buff));
-  DBUG_RETURN(length);
+  DBUG_RETURN((uint)length);
 }
 
 /*
@@ -2603,8 +2603,8 @@ int mysql_rm_table_no_locks(THD *thd, TABLE_LIST *tables, bool if_exists,
     }
     else
     {
-      PSI_CALL_drop_table_share(false, table->db.str, table->db.length,
-                                table->table_name.str, table->table_name.length);
+      PSI_CALL_drop_table_share(false, table->db.str, (uint)table->db.length,
+                                table->table_name.str, (uint)table->table_name.length);
       mysql_audit_drop_table(thd, table);
     }
 
@@ -2825,8 +2825,8 @@ bool quick_rm_table(THD *thd, handlerton *base, const LEX_CSTRING *db,
 
   if (likely(error == 0))
   {
-    PSI_CALL_drop_table_share(flags & FN_IS_TMP, db->str, db->length,
-                              table_name->str, table_name->length);
+    PSI_CALL_drop_table_share(flags & FN_IS_TMP, db->str, (uint)db->length,
+                              table_name->str, (uint)table_name->length);
   }
 
   DBUG_RETURN(error);
@@ -4329,7 +4329,7 @@ bool validate_comment_length(THD *thd, LEX_CSTRING *comment, size_t max_len,
                              uint err_code, const char *name)
 {
   DBUG_ENTER("validate_comment_length");
-  uint tmp_len= my_charpos(system_charset_info, comment->str,
+  size_t tmp_len= my_charpos(system_charset_info, comment->str,
                            comment->str + comment->length, max_len);
   if (tmp_len < comment->length)
   {
@@ -5563,8 +5563,8 @@ mysql_rename_table(handlerton *base, const LEX_CSTRING *old_db,
   if (likely(error == 0))
   {
     PSI_CALL_drop_table_share(flags & FN_FROM_IS_TMP,
-                              old_db->str, old_db->length,
-                              old_name->str, old_name->length);
+                              old_db->str, (uint)old_db->length,
+                              old_name->str, (uint)old_name->length);
   }
 
   // Restore options bits to the original value
diff --git a/sql/sql_table.h b/sql/sql_table.h
index 27f649e6dc7..9958a56958e 100644
--- a/sql/sql_table.h
+++ b/sql/sql_table.h
@@ -141,10 +141,10 @@ static const uint SKIP_SYMDIR_ACCESS= 1 << 5;
 /** Don't check foreign key constraints while renaming table */
 static const uint NO_FK_CHECKS=    1 << 6;
 
-uint filename_to_tablename(const char *from, char *to, uint to_length,
+uint filename_to_tablename(const char *from, char *to, size_t to_length,
                            bool stay_quiet = false);
-uint tablename_to_filename(const char *from, char *to, uint to_length);
-uint check_n_cut_mysql50_prefix(const char *from, char *to, uint to_length);
+uint tablename_to_filename(const char *from, char *to, size_t to_length);
+uint check_n_cut_mysql50_prefix(const char *from, char *to, size_t to_length);
 bool check_mysql50_prefix(const char *name);
 uint build_table_filename(char *buff, size_t bufflen, const char *db,
                           const char *table, const char *ext, uint flags);
diff --git a/sql/sql_time.cc b/sql/sql_time.cc
index 567739243ff..0dfb1c4d88b 100644
--- a/sql/sql_time.cc
+++ b/sql/sql_time.cc
@@ -256,8 +256,8 @@ adjust_time_range_with_warn(MYSQL_TIME *ltime, uint dec)
 */
 static uint
 to_ascii(CHARSET_INFO *cs,
-         const char *src, uint src_length,
-         char *dst, uint dst_length)
+         const char *src, size_t src_length,
+         char *dst, size_t dst_length)
                      
 {
   int cnvres;
@@ -280,7 +280,7 @@ to_ascii(CHARSET_INFO *cs,
 
 /* Character set-aware version of str_to_time() */
 bool
-str_to_time(CHARSET_INFO *cs, const char *str,uint length,
+str_to_time(CHARSET_INFO *cs, const char *str, size_t length,
             MYSQL_TIME *l_time, ulonglong fuzzydate, MYSQL_TIME_STATUS *status)
 {
   char cnv[32];
@@ -294,7 +294,7 @@ str_to_time(CHARSET_INFO *cs, const char *str,uint length,
 
 
 /* Character set-aware version of str_to_datetime() */
-bool str_to_datetime(CHARSET_INFO *cs, const char *str, uint length,
+bool str_to_datetime(CHARSET_INFO *cs, const char *str, size_t length,
                      MYSQL_TIME *l_time, ulonglong flags,
                      MYSQL_TIME_STATUS *status)
 {
@@ -318,7 +318,7 @@ bool str_to_datetime(CHARSET_INFO *cs, const char *str, uint length,
 
 bool
 str_to_datetime_with_warn(CHARSET_INFO *cs,
-                          const char *str, uint length, MYSQL_TIME *l_time,
+                          const char *str, size_t length, MYSQL_TIME *l_time,
                           ulonglong flags)
 {
   MYSQL_TIME_STATUS status;
@@ -786,7 +786,7 @@ DATE_TIME_FORMAT
 DATE_TIME_FORMAT *date_time_format_copy(THD *thd, DATE_TIME_FORMAT *format)
 {
   DATE_TIME_FORMAT *new_format;
-  ulong length= sizeof(*format) + format->format.length + 1;
+  size_t length= sizeof(*format) + format->format.length + 1;
   char *format_pos;
 
   if (thd)
diff --git a/sql/sql_time.h b/sql/sql_time.h
index 28a2e2f50d2..94f24be3748 100644
--- a/sql/sql_time.h
+++ b/sql/sql_time.h
@@ -38,8 +38,7 @@ bool time_to_datetime(MYSQL_TIME *ltime);
 void time_to_daytime_interval(MYSQL_TIME *l_time);
 bool get_date_from_daynr(long daynr,uint *year, uint *month, uint *day);
 my_time_t TIME_to_timestamp(THD *thd, const MYSQL_TIME *t, uint *error_code);
-bool str_to_datetime_with_warn(CHARSET_INFO *cs, const char *str,
-                               uint length, MYSQL_TIME *l_time,
+bool str_to_datetime_with_warn(CHARSET_INFO *cs, const char *str, size_t length, MYSQL_TIME *l_time,
                                ulonglong flags);
 bool double_to_datetime_with_warn(double value, MYSQL_TIME *ltime,
                                   ulonglong fuzzydate,
@@ -122,8 +121,7 @@ void make_truncated_value_warning(THD *thd,
                                   const char *field_name);
 
 static inline void make_truncated_value_warning(THD *thd,
-                Sql_condition::enum_warning_level level, const char *str_val,
-                uint str_length, timestamp_type time_type,
+                Sql_condition::enum_warning_level level, const char *str_val, size_t str_length, timestamp_type time_type,
                 const char *field_name)
 {
   const ErrConvString str(str_val, str_length, &my_charset_bin);
@@ -179,12 +177,12 @@ bool parse_date_time_format(timestamp_type format_type,
                             const char *format, uint format_length,
                             DATE_TIME_FORMAT *date_time_format);
 /* Character set-aware version of str_to_time() */
-bool str_to_time(CHARSET_INFO *cs, const char *str,uint length,
+bool str_to_time(CHARSET_INFO *cs, const char *str,size_t length,
                  MYSQL_TIME *l_time, ulonglong fuzzydate,
                  MYSQL_TIME_STATUS *status);
 /* Character set-aware version of str_to_datetime() */
 bool str_to_datetime(CHARSET_INFO *cs,
-                     const char *str, uint length,
+                     const char *str, size_t length,
                      MYSQL_TIME *l_time, ulonglong flags,
                      MYSQL_TIME_STATUS *status);
 
diff --git a/sql/sql_trigger.cc b/sql/sql_trigger.cc
index cf772ca9ccc..3b40ba52b3d 100644
--- a/sql/sql_trigger.cc
+++ b/sql/sql_trigger.cc
@@ -35,7 +35,7 @@
 #include <mysys_err.h>
 
 LEX_CSTRING *make_lex_string(LEX_CSTRING *lex_str,
-                             const char* str, uint length,
+                             const char* str, size_t length,
                              MEM_ROOT *mem_root)
 {
   if (!(lex_str->str= strmake_root(mem_root, str, length)))
@@ -654,7 +654,7 @@ static void build_trig_stmt_query(THD *thd, TABLE_LIST *tables,
 {
   LEX_CSTRING stmt_definition;
   LEX *lex= thd->lex;
-  uint prefix_trimmed, suffix_trimmed;
+  size_t prefix_trimmed, suffix_trimmed;
   size_t original_length;
 
   /*
diff --git a/sql/sql_udf.cc b/sql/sql_udf.cc
index 0f4310fdec1..3eb50d45b42 100644
--- a/sql/sql_udf.cc
+++ b/sql/sql_udf.cc
@@ -312,7 +312,7 @@ static void del_udf(udf_func *udf)
       doesn't use it anymore
     */
     const char *name= udf->name.str;
-    uint name_length=udf->name.length;
+    size_t name_length=udf->name.length;
     udf->name.str= "*";
     udf->name.length=1;
     my_hash_update(&udf_hash,(uchar*) udf,(uchar*) name,name_length);
@@ -347,7 +347,7 @@ void free_udf(udf_func *udf)
 
 /* This is only called if using_udf_functions != 0 */
 
-udf_func *find_udf(const char *name,uint length,bool mark_used)
+udf_func *find_udf(const char *name,size_t length,bool mark_used)
 {
   udf_func *udf=0;
   DBUG_ENTER("find_udf");
@@ -432,7 +432,7 @@ static int mysql_drop_function_internal(THD *thd, udf_func *udf, TABLE *table)
   DBUG_ENTER("mysql_drop_function_internal");
 
   const char *exact_name_str= udf->name.str;
-  uint exact_name_len= udf->name.length;
+  size_t exact_name_len= udf->name.length;
 
   del_udf(udf);
   /*
diff --git a/sql/sql_udf.h b/sql/sql_udf.h
index 1c805227f97..6e6fed2a81a 100644
--- a/sql/sql_udf.h
+++ b/sql/sql_udf.h
@@ -137,7 +137,7 @@ class udf_handler :public Sql_alloc
 
 #ifdef HAVE_DLOPEN
 void udf_init(void),udf_free(void);
-udf_func *find_udf(const char *name, uint len, bool mark_used=0);
+udf_func *find_udf(const char *name, size_t size, bool mark_used=0);
 void free_udf(udf_func *udf);
 int mysql_create_function(THD *thd,udf_func *udf);
 int mysql_drop_function(THD *thd, const LEX_CSTRING *name);
diff --git a/sql/sql_view.cc b/sql/sql_view.cc
index f6e0e4dc013..22f90808fdc 100644
--- a/sql/sql_view.cc
+++ b/sql/sql_view.cc
@@ -171,7 +171,7 @@ err:
 void make_valid_column_names(THD *thd, List<Item> &item_list)
 {
   Item *item;
-  uint name_len;
+  size_t name_len;
   List_iterator_fast<Item> it(item_list);
   char buff[NAME_LEN];
   DBUG_ENTER("make_valid_column_names");
@@ -1348,7 +1348,7 @@ bool mysql_make_view(THD *thd, TABLE_SHARE *share, TABLE_LIST *table,
     bool dbchanged;
     Parser_state parser_state;
     if (parser_state.init(thd, table->select_stmt.str,
-                          table->select_stmt.length))
+                          (uint)table->select_stmt.length))
         goto err;
 
     /* 
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 792968d7c44..9cb52ffd432 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -80,7 +80,7 @@ int yylex(void *yylval, void *yythd);
 
 #define yyoverflow(A,B,C,D,E,F)               \
   {                                           \
-    ulong val= *(F);                          \
+    size_t val= *(F);                          \
     if (my_yyoverflow((B), (D), &val))        \
     {                                         \
       yyerror(thd, (char*) (A));              \
@@ -897,7 +897,7 @@ Virtual_column_info *add_virtual_expression(THD *thd, Item *expr)
 }
 
 %{
-bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
+bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
 %}
 
 %pure-parser                                    /* We have threads */
@@ -4981,7 +4981,7 @@ size_number:
             uint text_shift_number= 0;
             longlong prefix_number;
             const char *start_ptr= $1.str;
-            uint str_len= $1.length;
+            size_t str_len= $1.length;
             const char *end_ptr= start_ptr + str_len;
             int error;
             prefix_number= my_strtoll10(start_ptr, (char**) &end_ptr, &error);
@@ -15082,7 +15082,7 @@ IDENT_sys:
             if (thd->charset_is_system_charset)
             {
               CHARSET_INFO *cs= system_charset_info;
-              uint wlen= Well_formed_prefix(cs, $1.str, $1.length).length();
+              size_t wlen= Well_formed_prefix(cs, $1.str, $1.length).length();
               if (wlen < $1.length)
               {
                 ErrConvString err($1.str, $1.length, &my_charset_bin);
@@ -17248,13 +17248,11 @@ view_select:
           {
             LEX *lex= Lex;
             size_t len= YYLIP->get_cpp_ptr() - lex->create_view->select.str;
-            uint not_used;
             void *create_view_select= thd->memdup(lex->create_view->select.str, len);
             lex->create_view->select.length= len;
             lex->create_view->select.str= (char *) create_view_select;
             trim_whitespace(thd->charset(),
-                            &lex->create_view->select,
-                            &not_used);
+                            &lex->create_view->select);
             lex->create_view->check= $4;
             lex->parsing_options.allows_variable= TRUE;
             lex->current_select->set_with_clause($2);
diff --git a/sql/sql_yacc_ora.yy b/sql/sql_yacc_ora.yy
index 63d9e381c37..48e778f1661 100644
--- a/sql/sql_yacc_ora.yy
+++ b/sql/sql_yacc_ora.yy
@@ -78,7 +78,7 @@ int yylex(void *yylval, void *yythd);
 
 #define yyoverflow(A,B,C,D,E,F)               \
   {                                           \
-    ulong val= *(F);                          \
+    size_t val= *(F);                          \
     if (my_yyoverflow((B), (D), &val))        \
     {                                         \
       yyerror(thd, (char*) (A));              \
@@ -268,7 +268,7 @@ void ORAerror(THD *thd, const char *s)
 }
 
 %{
-bool my_yyoverflow(short **a, YYSTYPE **b, ulong *yystacksize);
+bool my_yyoverflow(short **a, YYSTYPE **b, size_t *yystacksize);
 %}
 
 %pure-parser                                    /* We have threads */
@@ -4631,7 +4631,7 @@ size_number:
             uint text_shift_number= 0;
             longlong prefix_number;
             const char *start_ptr= $1.str;
-            uint str_len= $1.length;
+            size_t str_len= $1.length;
             const char *end_ptr= start_ptr + str_len;
             int error;
             prefix_number= my_strtoll10(start_ptr, (char**) &end_ptr, &error);
@@ -14547,7 +14547,7 @@ IDENT_sys:
             if (thd->charset_is_system_charset)
             {
               CHARSET_INFO *cs= system_charset_info;
-              uint wlen= Well_formed_prefix(cs, $1.str, $1.length).length();
+              size_t wlen= Well_formed_prefix(cs, $1.str, $1.length).length();
               if (wlen < $1.length)
               {
                 ErrConvString err($1.str, $1.length, &my_charset_bin);
@@ -16789,13 +16789,11 @@ view_select:
           {
             LEX *lex= Lex;
             size_t len= YYLIP->get_cpp_ptr() - lex->create_view->select.str;
-            uint not_used;
             void *create_view_select= thd->memdup(lex->create_view->select.str, len);
             lex->create_view->select.length= len;
             lex->create_view->select.str= (char *) create_view_select;
             trim_whitespace(thd->charset(),
-                            &lex->create_view->select,
-                            &not_used);
+                            &lex->create_view->select);
             lex->create_view->check= $4;
             lex->parsing_options.allows_variable= TRUE;
             lex->current_select->set_with_clause($2);
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 45a0f8f6558..43089684061 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -45,7 +45,7 @@
 
 static const char field_separator=',';
 
-ulonglong find_set(TYPELIB *lib, const char *str, uint length, CHARSET_INFO *cs,
+ulonglong find_set(TYPELIB *lib, const char *str, size_t length, CHARSET_INFO *cs,
                    char **err_pos, uint *err_len, bool *set_warning)
 {
   CHARSET_INFO *strip= cs ? cs : &my_charset_latin1;
@@ -111,7 +111,7 @@ ulonglong find_set(TYPELIB *lib, const char *str, uint length, CHARSET_INFO *cs,
   > 0 position in TYPELIB->type_names +1
 */
 
-uint find_type(const TYPELIB *lib, const char *find, uint length,
+uint find_type(const TYPELIB *lib, const char *find, size_t length,
                bool part_match)
 {
   uint found_count=0, found_pos=0;
@@ -152,7 +152,7 @@ uint find_type(const TYPELIB *lib, const char *find, uint length,
     >0  Offset+1 in typelib for matched string
 */
 
-uint find_type2(const TYPELIB *typelib, const char *x, uint length,
+uint find_type2(const TYPELIB *typelib, const char *x, size_t length,
                 CHARSET_INFO *cs)
 {
   int pos;
@@ -265,8 +265,8 @@ uint check_word(TYPELIB *lib, const char *val, const char *end,
 */
 
 
-uint strconvert(CHARSET_INFO *from_cs, const char *from, uint from_length,
-                CHARSET_INFO *to_cs, char *to, uint to_length, uint *errors)
+uint strconvert(CHARSET_INFO *from_cs, const char *from, size_t from_length,
+                CHARSET_INFO *to_cs, char *to, size_t to_length, uint *errors)
 {
   int cnvres;
   my_wc_t wc;
diff --git a/sql/strfunc.h b/sql/strfunc.h
index 1aba0bff422..1bf3cbf47b3 100644
--- a/sql/strfunc.h
+++ b/sql/strfunc.h
@@ -18,15 +18,15 @@
 
 typedef struct st_typelib TYPELIB;
 
-ulonglong find_set(TYPELIB *lib, const char *x, uint length, CHARSET_INFO *cs,
+ulonglong find_set(TYPELIB *lib, const char *x, size_t length, CHARSET_INFO *cs,
 		   char **err_pos, uint *err_len, bool *set_warning);
 ulonglong find_set_from_flags(TYPELIB *lib, uint default_name,
                               ulonglong cur_set, ulonglong default_set,
                               const char *str, uint length, CHARSET_INFO *cs,
                               char **err_pos, uint *err_len, bool *set_warning);
-uint find_type(const TYPELIB *lib, const char *find, uint length,
+uint find_type(const TYPELIB *lib, const char *find, size_t length,
                bool part_match);
-uint find_type2(const TYPELIB *lib, const char *find, uint length,
+uint find_type2(const TYPELIB *lib, const char *find, size_t length,
                 CHARSET_INFO *cs);
 void unhex_type2(TYPELIB *lib);
 uint check_word(TYPELIB *lib, const char *val, const char *end,
@@ -42,7 +42,7 @@ const char *set_to_string(THD *thd, LEX_CSTRING *result, ulonglong set,
 /*
   These functions were protected by INNODB_COMPATIBILITY_HOOKS
  */
-uint strconvert(CHARSET_INFO *from_cs, const char *from, uint from_length,
-                CHARSET_INFO *to_cs, char *to, uint to_length, uint *errors);
+uint strconvert(CHARSET_INFO *from_cs, const char *from, size_t from_length,
+                CHARSET_INFO *to_cs, char *to, size_t to_length, uint *errors);
 
 #endif /* STRFUNC_INCLUDED */
diff --git a/sql/structs.h b/sql/structs.h
index 4a66ac63d23..4d05a2433cc 100644
--- a/sql/structs.h
+++ b/sql/structs.h
@@ -330,7 +330,7 @@ typedef struct st_user_stats
 typedef struct st_table_stats
 {
   char table[NAME_LEN * 2 + 2];  // [db] + '\0' + [table] + '\0'
-  uint table_name_length;
+  size_t table_name_length;
   ulonglong rows_read, rows_changed;
   ulonglong rows_changed_x_indexes;
   /* Stores enum db_type, but forward declarations cannot be done */
@@ -341,7 +341,7 @@ typedef struct st_index_stats
 {
   // [db] + '\0' + [table] + '\0' + [index] + '\0'
   char index[NAME_LEN * 3 + 3];
-  uint index_name_length;                       /* Length of 'index' */
+  size_t index_name_length;                       /* Length of 'index' */
   ulonglong rows_read;
 } INDEX_STATS;
 
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index 94c77136993..4e49d524ce5 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -2819,7 +2819,7 @@ static Sys_var_enum Sys_thread_handling(
 #ifdef HAVE_QUERY_CACHE
 static bool fix_query_cache_size(sys_var *self, THD *thd, enum_var_type type)
 {
-  ulong new_cache_size= query_cache.resize((ulong)query_cache_size);
+  size_t new_cache_size= query_cache.resize((size_t)query_cache_size);
   /*
      Note: query_cache_size is a global variable reflecting the
      requested cache size. See also query_cache_size_arg
@@ -2827,7 +2827,7 @@ static bool fix_query_cache_size(sys_var *self, THD *thd, enum_var_type type)
   if (query_cache_size != new_cache_size)
     push_warning_printf(current_thd, Sql_condition::WARN_LEVEL_WARN,
                         ER_WARN_QC_RESIZE, ER_THD(thd, ER_WARN_QC_RESIZE),
-                        query_cache_size, new_cache_size);
+                        query_cache_size, (ulong)new_cache_size);
 
   query_cache_size= new_cache_size;
 
@@ -2858,7 +2858,7 @@ static Sys_var_ulong Sys_query_cache_limit(
 static bool fix_qcache_min_res_unit(sys_var *self, THD *thd, enum_var_type type)
 {
   query_cache_min_res_unit=
-    query_cache.set_min_res_unit(query_cache_min_res_unit);
+    (ulong)query_cache.set_min_res_unit(query_cache_min_res_unit);
   return false;
 }
 static Sys_var_ulong Sys_query_cache_min_res_unit(
diff --git a/sql/sys_vars_shared.h b/sql/sys_vars_shared.h
index ff050f63064..48154c95a72 100644
--- a/sql/sys_vars_shared.h
+++ b/sql/sys_vars_shared.h
@@ -32,7 +32,7 @@ extern bool throw_bounds_warning(THD *thd, const char *name,
                                  bool fixed, bool is_unsigned, longlong v);
 extern bool throw_bounds_warning(THD *thd, const char *name, bool fixed,
                                  double v);
-extern sys_var *intern_find_sys_var(const char *str, uint length);
+extern sys_var *intern_find_sys_var(const char *str, size_t length);
 
 extern sys_var_chain all_sys_vars;
 
diff --git a/sql/table.cc b/sql/table.cc
index f220e21920d..5546c5b497f 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -87,7 +87,7 @@ static void fix_type_pointers(const char ***array, TYPELIB *point_to_type,
 			      uint types, char **names);
 static uint find_field(Field **fields, uchar *record, uint start, uint length);
 
-inline bool is_system_table_name(const char *name, uint length);
+inline bool is_system_table_name(const char *name, size_t length);
 
 /**************************************************************************
   Object_creation_ctx implementation.
@@ -509,7 +509,7 @@ void free_table_share(TABLE_SHARE *share)
   and should not contain user tables.
 */
 
-inline bool is_system_table_name(const char *name, uint length)
+inline bool is_system_table_name(const char *name, size_t length)
 {
   CHARSET_INFO *ci= system_charset_info;
 
@@ -1190,10 +1190,11 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
   enum legacy_db_type legacy_db_type;
   my_bitmap_map *bitmaps;
   bool null_bits_are_used;
-  uint vcol_screen_length, UNINIT_VAR(options_len);
+  uint vcol_screen_length;
+  size_t UNINIT_VAR(options_len);
   uchar *vcol_screen_pos;
   const uchar *options= 0;
-  uint UNINIT_VAR(gis_options_len);
+  size_t UNINIT_VAR(gis_options_len);
   const uchar *gis_options= 0;
   KEY first_keyinfo;
   uint len;
@@ -1711,7 +1712,7 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
       for (count= 0; count < interval->count; count++)
       {
         char *val= (char*) interval->type_names[count];
-        interval->type_lengths[count]= strlen(val);
+        interval->type_lengths[count]= (uint)strlen(val);
       }
       interval->type_lengths[count]= 0;
     }
@@ -3804,7 +3805,7 @@ static uint find_field(Field **fields, uchar *record, uint start, uint length)
     May fail with some multibyte charsets though.
 */
 
-void append_unescaped(String *res, const char *pos, uint length)
+void append_unescaped(String *res, const char *pos, size_t length)
 {
   const char *end= pos+length;
   res->append('\'');
@@ -3855,7 +3856,7 @@ void append_unescaped(String *res, const char *pos, uint length)
 void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
                         HA_CREATE_INFO *create_info, uint keys, KEY *key_info)
 {
-  ulong key_comment_total_bytes= 0;
+  size_t key_comment_total_bytes= 0;
   uint i;
   DBUG_ENTER("prepare_frm_header");
 
@@ -3865,7 +3866,7 @@ void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
   if (create_info->min_rows > UINT_MAX32)
     create_info->min_rows= UINT_MAX32;
 
-  uint key_length, tmp_key_length, tmp, csid;
+  size_t key_length, tmp_key_length, tmp, csid;
   bzero((char*) fileinfo, FRM_HEADER_SIZE);
   /* header */
   fileinfo[0]=(uchar) 254;
@@ -4091,7 +4092,7 @@ bool ok_for_lower_case_names(const char *name)
 bool check_db_name(LEX_STRING *org_name)
 {
   char *name= org_name->str;
-  uint name_length= org_name->length;
+  size_t name_length= org_name->length;
   bool check_for_path_chars;
 
   if ((check_for_path_chars= check_mysql50_prefix(name)))
@@ -8937,7 +8938,7 @@ void vers_select_conds_t::resolve_units(bool timestamps_only)
 
 Field *TABLE::find_field_by_name(LEX_CSTRING *str) const
 {
-  uint length= str->length;
+  size_t length= str->length;
   for (Field **tmp= field; *tmp; tmp++)
   {
     if ((*tmp)->field_name.length == length &&
diff --git a/sql/table.h b/sql/table.h
index 79742ff7111..b6adbfc6188 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -1074,7 +1074,7 @@ public:
      @retval Pointer to the copied string.
      @retval 0 if an error occurred.
   */
-  char *store(const char *from, uint length)
+  char *store(const char *from, size_t length)
   {
     return (char*) memdup_root(&storage, from, length);
   }
@@ -2791,7 +2791,7 @@ typedef struct st_changed_table_list
 {
   struct	st_changed_table_list *next;
   char		*key;
-  uint32        key_length;
+  size_t  key_length;
 } CHANGED_TABLE_LIST;
 
 
@@ -2916,7 +2916,7 @@ int closefrm(TABLE *table);
 void free_blobs(TABLE *table);
 void free_field_buffers_larger_than(TABLE *table, uint32 size);
 ulong get_form_pos(File file, uchar *head, TYPELIB *save_names);
-void append_unescaped(String *res, const char *pos, uint length);
+void append_unescaped(String *res, const char *pos, size_t length);
 void prepare_frm_header(THD *thd, uint reclength, uchar *fileinfo,
                         HA_CREATE_INFO *create_info, uint keys, KEY *key_info);
 const char *fn_frm_ext(const char *name);
diff --git a/sql/table_cache.cc b/sql/table_cache.cc
index 5ca4dd9f175..18ea7f83964 100644
--- a/sql/table_cache.cc
+++ b/sql/table_cache.cc
@@ -587,17 +587,17 @@ static void lf_alloc_destructor(uchar *arg)
 }
 
 
-static void tdc_hash_initializer(LF_HASH *hash __attribute__((unused)),
+static void tdc_hash_initializer(LF_HASH *,
                                  TDC_element *element, LEX_STRING *key)
 {
   memcpy(element->m_key, key->str, key->length);
-  element->m_key_length= key->length;
+  element->m_key_length= (uint)key->length;
   tdc_assert_clean_share(element);
 }
 
 
 static uchar *tdc_hash_key(const TDC_element *element, size_t *length,
-                           my_bool not_used __attribute__((unused)))
+                           my_bool)
 {
   *length= element->m_key_length;
   return (uchar*) element->m_key;
diff --git a/sql/temporary_tables.cc b/sql/temporary_tables.cc
index 9be9468fd74..4c6671cc2ae 100644
--- a/sql/temporary_tables.cc
+++ b/sql/temporary_tables.cc
@@ -263,7 +263,7 @@ TMP_TABLE_SHARE *THD::find_tmp_table_share(const TABLE_LIST *tl)
   @return Success                     A pointer to table share object
           Failure                     NULL
 */
-TMP_TABLE_SHARE *THD::find_tmp_table_share(const char *key, uint key_length)
+TMP_TABLE_SHARE *THD::find_tmp_table_share(const char *key, size_t key_length)
 {
   DBUG_ENTER("THD::find_tmp_table_share");
 
diff --git a/sql/transaction.cc b/sql/transaction.cc
index ec277e9c9c4..a11ad13a7dc 100644
--- a/sql/transaction.cc
+++ b/sql/transaction.cc
@@ -653,7 +653,7 @@ bool trans_savepoint(THD *thd, LEX_CSTRING name)
   }
 
   newsv->name= strmake_root(&thd->transaction.mem_root, name.str, name.length);
-  newsv->length= name.length;
+  newsv->length= (uint)name.length;
 
   /*
     if we'll get an error here, don't add new savepoint to the list.
diff --git a/sql/tztime.cc b/sql/tztime.cc
index 7af218b3cb6..f7e2dcbefb8 100644
--- a/sql/tztime.cc
+++ b/sql/tztime.cc
@@ -166,7 +166,7 @@ static my_bool
 tz_load(const char *name, TIME_ZONE_INFO *sp, MEM_ROOT *storage)
 {
   uchar *p;
-  int read_from_file;
+  ssize_t read_from_file;
   uint i;
   MYSQL_FILE *file;
 
@@ -187,7 +187,7 @@ tz_load(const char *name, TIME_ZONE_INFO *sp, MEM_ROOT *storage)
     uint ttisgmtcnt;
     char *tzinfo_buf;
 
-    read_from_file= mysql_file_fread(file, u.buf, sizeof(u.buf), MYF(MY_WME));
+    read_from_file= (ssize_t)mysql_file_fread(file, u.buf, sizeof(u.buf), MYF(MY_WME));
 
     if (mysql_file_fclose(file, MYF(MY_WME)) != 0)
       return 1;
@@ -1333,7 +1333,7 @@ Time_zone_offset::Time_zone_offset(long tz_offset_arg):
 {
   uint hours= abs((int)(offset / SECS_PER_HOUR));
   uint minutes= abs((int)(offset % SECS_PER_HOUR / SECS_PER_MIN));
-  ulong length= my_snprintf(name_buff, sizeof(name_buff), "%s%02d:%02d",
+  size_t length= my_snprintf(name_buff, sizeof(name_buff), "%s%02d:%02d",
                             (offset>=0) ? "+" : "-", hours, minutes);
   name.set(name_buff, length, &my_charset_latin1);
 }
diff --git a/sql/uniques.cc b/sql/uniques.cc
index 894e959cace..8ed1ceda6a1 100644
--- a/sql/uniques.cc
+++ b/sql/uniques.cc
@@ -312,7 +312,7 @@ double Unique::get_use_cost(uint *buffer, size_t nkeys, uint key_size,
 {
   size_t max_elements_in_tree;
   size_t last_tree_elems;
-  int   n_full_trees; /* number of trees in unique - 1 */
+  size_t   n_full_trees; /* number of trees in unique - 1 */
   double result;
 
   max_elements_in_tree= ((size_t) max_in_memory_size /
@@ -350,9 +350,9 @@ double Unique::get_use_cost(uint *buffer, size_t nkeys, uint key_size,
   /* Cost of merge */
   if (intersect_fl)
     key_size+= sizeof(element_count);
-  double merge_cost= get_merge_many_buffs_cost(buffer, n_full_trees,
-                                               max_elements_in_tree,
-                                               last_tree_elems, key_size,
+  double merge_cost= get_merge_many_buffs_cost(buffer, (uint)n_full_trees,
+                                               (uint)max_elements_in_tree,
+                                               (uint)last_tree_elems, key_size,
                                                compare_factor);
   result += merge_cost;
   /*
diff --git a/sql/unireg.cc b/sql/unireg.cc
index cbab0b3533b..50094ceed47 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -172,12 +172,13 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
   LEX_CSTRING str_db_type;
   uint reclength, key_info_length, i;
   ulong key_buff_length;
-  ulong filepos, data_offset;
+  size_t filepos;
+  ulong data_offset;
   uint options_len;
   uint gis_extra2_len= 0;
   uchar fileinfo[FRM_HEADER_SIZE],forminfo[FRM_FORMINFO_SIZE];
   const partition_info *part_info= IF_PARTITIONING(thd->work_part_info, 0);
-  int error;
+  bool error;
   uchar *frm_ptr, *pos;
   LEX_CUSTRING frm= {0,0};
   StringBuffer<MAX_FIELD_WIDTH> vcols;
@@ -200,7 +201,7 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
     create_info->expression_length= vcols.length() + FRM_VCOL_NEW_BASE_SIZE;
 
   error= pack_header(thd, forminfo, create_fields, create_info,
-                     data_offset, db_file);
+                     (ulong)data_offset, db_file);
   if (error)
     DBUG_RETURN(frm);
 
@@ -209,7 +210,7 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
   /* Calculate extra data segment length */
   str_db_type= *hton_name(create_info->db_type);
   /* str_db_type */
-  create_info->extra_size= (2 + str_db_type.length +
+  create_info->extra_size= (uint)(2 + str_db_type.length +
                             2 + create_info->connect_string.length);
   /*
     Partition:
@@ -220,12 +221,12 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
   */
   create_info->extra_size+= 6;
   if (part_info)
-    create_info->extra_size+= part_info->part_info_len;
+    create_info->extra_size+= (uint)part_info->part_info_len;
 
   for (i= 0; i < keys; i++)
   {
     if (key_info[i].parser_name)
-      create_info->extra_size+= key_info[i].parser_name->length + 1;
+      create_info->extra_size+= (uint)key_info[i].parser_name->length + 1;
   }
 
   options_len= engine_table_options_frm_length(create_info->option_list,
@@ -247,7 +248,7 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
   if (create_info->comment.length > TABLE_COMMENT_INLINE_MAXLEN)
   {
     forminfo[46]=255;
-    create_info->extra_size+= 2 + create_info->comment.length;
+    create_info->extra_size+= 2 + (uint)create_info->comment.length;
   }
   else
   {
@@ -271,7 +272,7 @@ LEX_CUSTRING build_frm_image(THD *thd, const LEX_CSTRING *table,
   prepare_frm_header(thd, reclength, fileinfo, create_info, keys, key_info);
 
   /* one byte for a type, one or three for a length */
-  uint extra2_size= 1 + 1 + create_info->tabledef_version.length;
+  size_t extra2_size= 1 + 1 + create_info->tabledef_version.length;
   if (options_len)
     extra2_size+= 1 + (options_len > 255 ? 3 : 1) + options_len;
 
@@ -762,10 +763,10 @@ static bool pack_header(THD *thd, uchar *forminfo,
         {
           char *dst;
           const char *src= field->save_interval->type_names[pos];
-          uint hex_length;
+          size_t hex_length;
           length= field->save_interval->type_lengths[pos];
           hex_length= length * 2;
-          field->interval->type_lengths[pos]= hex_length;
+          field->interval->type_lengths[pos]= (uint)hex_length;
           field->interval->type_names[pos]= dst=
             (char*) thd->alloc(hex_length + 1);
           octet2hex(dst, src, length);
@@ -889,7 +890,8 @@ static bool pack_fields(uchar **buff_arg, List<Create_field> &create_fields,
                         ulong data_offset)
 {
   uchar *buff= *buff_arg;
-  uint int_count, comment_length= 0;
+  uint int_count;
+  size_t comment_length= 0;
   Create_field *field;
   DBUG_ENTER("pack_fields");
 
diff --git a/sql/vers_string.h b/sql/vers_string.h
index 756aea82794..0760613cd89 100644
--- a/sql/vers_string.h
+++ b/sql/vers_string.h
@@ -54,20 +54,20 @@ struct LEX_STRING_u : public Storage
     Storage::str= NULL;
     Storage::length= 0;
   }
-  LEX_STRING_u(const char *_str, uint32 _len, CHARSET_INFO *)
+  LEX_STRING_u(const char *_str, size_t _len, CHARSET_INFO *)
   {
     Storage::str= _str;
     Storage::length= _len;
   }
   uint32 length() const
   {
-    return Storage::length;
+    return (uint32)Storage::length;
   }
   const char *ptr() const
   {
     return Storage::str;
   }
-  void set(const char *_str, uint32 _len, CHARSET_INFO *)
+  void set(const char *_str, size_t _len, CHARSET_INFO *)
   {
     Storage::str= _str;
     Storage::length= _len;
diff --git a/sql/wsrep_mysqld.cc b/sql/wsrep_mysqld.cc
index 299f40fff3d..91a77c65604 100644
--- a/sql/wsrep_mysqld.cc
+++ b/sql/wsrep_mysqld.cc
@@ -2660,11 +2660,10 @@ static int wsrep_create_trigger_query(THD *thd, uchar** buf, size_t* buf_len)
   append_definer(thd, &stmt_query, &definer_user, &definer_host);
 
   LEX_CSTRING stmt_definition;
-  uint not_used;
   stmt_definition.str= (char*) thd->lex->stmt_definition_begin;
   stmt_definition.length= thd->lex->stmt_definition_end
     - thd->lex->stmt_definition_begin;
-  trim_whitespace(thd->charset(), &stmt_definition, &not_used);
+  trim_whitespace(thd->charset(), &stmt_definition);
 
   stmt_query.append(stmt_definition.str, stmt_definition.length);