Windows : Fix truncation warnings in sql/

30 files changed, 142 insertions, 142 deletions

diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index 92f18d7402f..df09beeb274 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -3657,7 +3657,7 @@ bool Item_func_group_concat::setup(THD *thd)
       syntax of this function). If there is no ORDER BY clause, we don't
       create this tree.
     */
-    init_tree(tree, (uint) MY_MIN(thd->variables.max_heap_table_size,
+    init_tree(tree, (size_t)MY_MIN(thd->variables.max_heap_table_size,
                                thd->variables.sortbuff_size/16), 0,
               tree_key_length, 
               group_concat_key_cmp_with_order, NULL, (void*) this,
diff --git a/sql/item_xmlfunc.cc b/sql/item_xmlfunc.cc
index 10dda8f20e8..57b1807d78c 100644
--- a/sql/item_xmlfunc.cc
+++ b/sql/item_xmlfunc.cc
@@ -176,7 +176,7 @@ public:
   {
     nodebeg= (MY_XML_NODE*) pxml->ptr();
     nodeend= (MY_XML_NODE*) (pxml->ptr() + pxml->length());
-    numnodes= nodeend - nodebeg;
+    numnodes= (uint)(nodeend - nodebeg);
   }
   void prepare(String *nodeset)
   {
@@ -615,7 +615,7 @@ public:
         if ((node->parent == flt->num) &&
             (node->type == MY_XML_NODE_TEXT))
         {
-          fake->set_value(node->beg, node->end - node->beg,
+          fake->set_value(node->beg, (uint)(node->end - node->beg),
                           collation.collation);
           if (args[1]->val_int())
             return 1;
@@ -817,7 +817,7 @@ String *Item_nodeset_func_predicate::val_nodeset(String *str)
   Item_func *comp_func= (Item_func*)args[1];
   uint pos= 0, size;
   prepare(str);
-  size= fltend - fltbeg;
+  size= (uint)(fltend - fltbeg);
   for (MY_XPATH_FLT *flt= fltbeg; flt < fltend; flt++)
   {
     nodeset_func->context_cache.length(0);
@@ -836,7 +836,7 @@ String *Item_nodeset_func_elementbyindex::val_nodeset(String *nodeset)
   Item_nodeset_func *nodeset_func= (Item_nodeset_func*) args[0];
   prepare(nodeset);
   MY_XPATH_FLT *flt;
-  uint pos, size= fltend - fltbeg;
+  uint pos, size= (uint)(fltend - fltbeg);
   for (pos= 0, flt= fltbeg; flt < fltend; flt++)
   {
     nodeset_func->context_cache.length(0);
@@ -995,7 +995,7 @@ static Item *create_comparator(MY_XPATH *xpath,
   else if (a->type() == Item::XPATH_NODESET &&
            b->type() == Item::XPATH_NODESET)
   {
-    uint len= xpath->query.end - context->beg;
+    uint len= (uint)(xpath->query.end - context->beg);
     set_if_smaller(len, 32);
     my_printf_error(ER_UNKNOWN_ERROR,
                     "XPATH error: "
@@ -1399,7 +1399,7 @@ MY_XPATH_FUNC *
 my_xpath_function(const char *beg, const char *end)
 {
   MY_XPATH_FUNC *k, *function_names;
-  uint length= end-beg;
+  uint length= (uint)(end-beg);
   switch (length)
   {
     case 1: return 0;
@@ -1961,7 +1961,7 @@ static int my_xpath_parse_PrimaryExpr_literal(MY_XPATH *xpath)
     return 0;
   xpath->item= new (xpath->thd->mem_root)
     Item_string(xpath->thd, xpath->prevtok.beg + 1,
-                xpath->prevtok.end - xpath->prevtok.beg - 2,
+                (uint)(xpath->prevtok.end - xpath->prevtok.beg - 2),
                 xpath->cs);
   return 1;
 }
@@ -2499,13 +2499,13 @@ static int my_xpath_parse_Number(MY_XPATH *xpath)
   if (!my_xpath_parse_term(xpath, MY_XPATH_LEX_DOT))
   {
     xpath->item= new (thd->mem_root) Item_int(thd, xpath->prevtok.beg,
-                              xpath->prevtok.end - xpath->prevtok.beg);
+                              (uint)(xpath->prevtok.end - xpath->prevtok.beg));
     return 1;
   }
   my_xpath_parse_term(xpath, MY_XPATH_LEX_DIGITS);
 
   xpath->item= new (thd->mem_root) Item_float(thd, beg,
-                                              xpath->prevtok.end - beg);
+                                              (uint)(xpath->prevtok.end - beg));
   return 1;
 }
 
@@ -2632,7 +2632,7 @@ my_xpath_parse_VariableReference(MY_XPATH *xpath)
     {
       xpath->item= NULL;
       DBUG_ASSERT(xpath->query.end > dollar_pos);
-      uint len= xpath->query.end - dollar_pos;
+      uint len= (uint)(xpath->query.end - dollar_pos);
       set_if_smaller(len, 32);
       my_printf_error(ER_UNKNOWN_ERROR, "Unknown XPATH variable at: '%.*s'", 
                       MYF(0), len, dollar_pos);
@@ -2660,7 +2660,7 @@ my_xpath_parse_NodeTest_QName(MY_XPATH *xpath)
   if (!my_xpath_parse_QName(xpath))
     return 0;
   DBUG_ASSERT(xpath->context);
-  uint len= xpath->prevtok.end - xpath->prevtok.beg;
+  uint len= (uint)(xpath->prevtok.end - xpath->prevtok.beg);
   xpath->context= nametestfunc(xpath, xpath->axis, xpath->context,
                                xpath->prevtok.beg, len);
   return 1;
@@ -2759,7 +2759,7 @@ bool Item_xml_str_func::fix_fields(THD *thd, Item **ref)
 
   if (!rc)
   {
-    uint clen= xpath.query.end - xpath.lasttok.beg;
+    uint clen= (uint)(xpath.query.end - xpath.lasttok.beg);
     set_if_smaller(clen, 32);
     my_printf_error(ER_UNKNOWN_ERROR, "XPATH syntax error: '%.*s'",
                     MYF(0), clen, xpath.lasttok.beg);
diff --git a/sql/log_event.cc b/sql/log_event.cc
index 81cf7d8c250..8932d0f261d 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -1131,7 +1131,7 @@ int append_query_string(CHARSET_INFO *csinfo, String *to,
 
     *ptr++= '\'';
   }
-  to->length(orig_len + ptr - beg);
+  to->length((uint32)(orig_len + ptr - beg));
   return 0;
 }
 #endif
@@ -10034,7 +10034,7 @@ Execute_load_query_log_event::do_apply_event(rpl_group_info *rgi)
   p= strmake(p, STRING_WITH_LEN(" INTO "));
   p= strmake(p, query+fn_pos_end, q_len-fn_pos_end);
 
-  error= Query_log_event::do_apply_event(rgi, buf, p-buf);
+  error= Query_log_event::do_apply_event(rgi, buf, (uint32)(p-buf));
 
   /* Forging file name for deletion in same buffer */
   *fname_end= 0;
@@ -10486,7 +10486,7 @@ int Rows_log_event::do_add_row_data(uchar *row_data, size_t length)
   if (static_cast<size_t>(m_rows_end - m_rows_cur) <= length)
   {
     size_t const block_size= 1024;
-    ulong cur_size= m_rows_cur - m_rows_buf;
+    size_t cur_size= m_rows_cur - m_rows_buf;
     DBUG_EXECUTE_IF("simulate_too_big_row_case1",
                      cur_size= UINT_MAX32 - (block_size * 10);
                      length= UINT_MAX32 - (block_size * 10););
@@ -10499,21 +10499,21 @@ int Rows_log_event::do_add_row_data(uchar *row_data, size_t length)
     DBUG_EXECUTE_IF("simulate_too_big_row_case4",
                      cur_size= UINT_MAX32 - (block_size * 10);
                      length= (block_size * 10) - block_size + 1;);
-    ulong remaining_space= UINT_MAX32 - cur_size;
+    size_t remaining_space= UINT_MAX32 - cur_size;
     /* Check that the new data fits within remaining space and we can add
        block_size without wrapping.
      */
-    if (length > remaining_space ||
+    if (cur_size > UINT_MAX32 || length > remaining_space ||
         ((length + block_size) > remaining_space))
     {
       sql_print_error("The row data is greater than 4GB, which is too big to "
                       "write to the binary log.");
       DBUG_RETURN(ER_BINLOG_ROW_LOGGING_FAILED);
     }
-    ulong const new_alloc= 
+    size_t const new_alloc= 
         block_size * ((cur_size + length + block_size - 1) / block_size);
 
-    uchar* const new_buf= (uchar*)my_realloc((uchar*)m_rows_buf, (uint) new_alloc,
+    uchar* const new_buf= (uchar*)my_realloc((uchar*)m_rows_buf, new_alloc,
                                            MYF(MY_ALLOW_ZERO_PTR|MY_WME));
     if (unlikely(!new_buf))
       DBUG_RETURN(HA_ERR_OUT_OF_MEM);
@@ -11246,11 +11246,11 @@ bool Rows_log_event::write_compressed()
   uchar *m_rows_cur_tmp = m_rows_cur;
   bool ret = true;
   uint32 comlen, alloc_size;
-  comlen= alloc_size= binlog_get_compress_len(m_rows_cur_tmp - m_rows_buf_tmp);
+  comlen= alloc_size= binlog_get_compress_len((uint32)(m_rows_cur_tmp - m_rows_buf_tmp));
   m_rows_buf = (uchar *)my_safe_alloca(alloc_size);
   if(m_rows_buf &&
      !binlog_buf_compress((const char *)m_rows_buf_tmp, (char *)m_rows_buf,
-                          m_rows_cur_tmp - m_rows_buf_tmp, &comlen))
+                          (uint32)(m_rows_cur_tmp - m_rows_buf_tmp), &comlen))
   {
     m_rows_cur= comlen + m_rows_buf;
     ret= Log_event::write();
@@ -12477,7 +12477,7 @@ Rows_log_event::write_row(rpl_group_info *rgi,
        the size of the first row and use that value to initialize
        storage engine for bulk insertion */
     DBUG_ASSERT(!(m_curr_row > m_curr_row_end));
-    ulong estimated_rows= 0;
+    ha_rows estimated_rows= 0;
     if (m_curr_row < m_curr_row_end)
       estimated_rows= (m_rows_end - m_curr_row) / (m_curr_row_end - m_curr_row);
     else if (m_curr_row == m_curr_row_end)
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index c784fb23898..0e1543ecd2f 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -8799,8 +8799,8 @@ static int mysql_init_variables(void)
 
   /* Set directory paths */
   mysql_real_data_home_len=
-    strmake_buf(mysql_real_data_home,
-                get_relative_path(MYSQL_DATADIR)) - mysql_real_data_home;
+    (uint)(strmake_buf(mysql_real_data_home,
+                get_relative_path(MYSQL_DATADIR)) - mysql_real_data_home);
   /* Replication parameters */
   master_info_file= (char*) "master.info",
     relay_log_info_file= (char*) "relay-log.info";
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index d4dfc5a65af..415b76a28bb 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -499,9 +499,9 @@ int SEL_IMERGE::or_sel_tree(RANGE_OPT_PARAM *param, SEL_TREE *tree)
   if (trees_next == trees_end)
   {
     const int realloc_ratio= 2;		/* Double size for next round */
-    uint old_elements= (trees_end - trees);
-    uint old_size= sizeof(SEL_TREE**) * old_elements;
-    uint new_size= old_size * realloc_ratio;
+    size_t old_elements= (trees_end - trees);
+    size_t old_size= sizeof(SEL_TREE**) * old_elements;
+    size_t new_size= old_size * realloc_ratio;
     SEL_TREE **new_trees;
     if (!(new_trees= (SEL_TREE**)alloc_root(param->mem_root, new_size)))
       return -1;
@@ -846,10 +846,10 @@ SEL_TREE::SEL_TREE(SEL_TREE *arg, bool without_merges,
 SEL_IMERGE::SEL_IMERGE(SEL_IMERGE *arg, uint cnt,
                        RANGE_OPT_PARAM *param) : Sql_alloc()
 {
-  uint elements= (arg->trees_end - arg->trees);
+  size_t elements= (arg->trees_end - arg->trees);
   if (elements > PREALLOCED_TREES)
   {
-    uint size= elements * sizeof (SEL_TREE **);
+    size_t size= elements * sizeof (SEL_TREE **);
     if (!(trees= (SEL_TREE **)alloc_root(param->mem_root, size)))
       goto mem_err;
   }
@@ -951,7 +951,7 @@ int imerge_list_or_list(RANGE_OPT_PARAM *param,
   uint rc;
   bool is_last_check_pass= FALSE;
   SEL_IMERGE *imerge= im1->head();
-  uint elems= imerge->trees_next-imerge->trees;
+  uint elems= (uint)(imerge->trees_next-imerge->trees);
   MEM_ROOT *mem_root= current_thd->mem_root;
 
   im1->empty();
@@ -1051,7 +1051,7 @@ int imerge_list_or_tree(RANGE_OPT_PARAM *param,
     SEL_TREE *or_tree= new (mem_root) SEL_TREE (tree, FALSE, param);
     if (or_tree)
     {
-      uint elems= imerge->trees_next-imerge->trees;
+      uint elems= (uint)(imerge->trees_next-imerge->trees);
       rc= imerge->or_sel_tree_with_checks(param, elems, or_tree,
                                           TRUE, &is_last_check_pass);
       if (!is_last_check_pass)
@@ -2897,7 +2897,7 @@ bool calculate_cond_selectivity_for_table(THD *thd, TABLE *table, Item **cond)
   uint keynr;
   uint max_quick_key_parts= 0;
   MY_BITMAP *used_fields= &table->cond_set;
-  double table_records= table->stat_records(); 
+  double table_records= (double)table->stat_records(); 
   DBUG_ENTER("calculate_cond_selectivity_for_table");
 
   table->cond_selectivity= 1.0;
@@ -3994,8 +3994,8 @@ int find_used_partitions(PART_PRUNE_PARAM *ppar, SEL_ARG *key_tree)
                                         store_length_array,
                                         range_par->min_key,
                                         range_par->max_key,
-                                        tmp_min_key - range_par->min_key,
-                                        tmp_max_key - range_par->max_key,
+                                        (uint)(tmp_min_key - range_par->min_key),
+                                        (uint)(tmp_max_key - range_par->max_key),
                                         flag,
                                         &ppar->part_iter);
         if (!res)
@@ -4659,7 +4659,7 @@ TABLE_READ_PLAN *get_best_disjunct_quick(PARAM *param, SEL_IMERGE *imerge,
     }
   }
 
-  uint n_child_scans= imerge->trees_next - imerge->trees;
+  size_t n_child_scans= imerge->trees_next - imerge->trees;
   
   if (!n_child_scans)
     DBUG_RETURN(NULL);
@@ -5203,7 +5203,7 @@ bool prepare_search_best_index_intersect(PARAM *param,
   INDEX_SCAN_INFO **scan_ptr;
   INDEX_SCAN_INFO *cpk_scan= NULL;
   TABLE *table= param->table;
-  uint n_index_scans= tree->index_scans_end - tree->index_scans;
+  uint n_index_scans= (uint)(tree->index_scans_end - tree->index_scans);
 
   if (!n_index_scans)
     return 1;
@@ -5846,7 +5846,7 @@ TRP_INDEX_INTERSECT *get_best_index_intersect(PARAM *param, SEL_TREE *tree,
     }
   }
   
-  count= tree->index_scans_end - tree->index_scans;
+  count= (uint)(tree->index_scans_end - tree->index_scans);
   for (i= 0; i < count; i++)
   {
     index_scan= tree->index_scans[i]; 
@@ -6506,7 +6506,7 @@ TRP_ROR_INTERSECT *get_best_ror_intersect(const PARAM *param, SEL_TREE *tree,
                                           intersect_scans_best););
 
   *are_all_covering= intersect->is_covering;
-  uint best_num= intersect_scans_best - intersect_scans;
+  uint best_num= (uint)(intersect_scans_best - intersect_scans);
   ror_intersect_cpy(intersect, intersect_best);
 
   /*
@@ -6688,7 +6688,7 @@ TRP_ROR_INTERSECT *get_best_covering_ror_intersect(PARAM *param,
   TRP_ROR_INTERSECT *trp;
   if (!(trp= new (param->mem_root) TRP_ROR_INTERSECT))
     DBUG_RETURN(trp);
-  uint best_num= (ror_scan_mark - tree->ror_scans);
+  uint best_num= (uint)(ror_scan_mark - tree->ror_scans);
   if (!(trp->first_scan= (ROR_SCAN_INFO**)alloc_root(param->mem_root,
                                                      sizeof(ROR_SCAN_INFO*)*
                                                      best_num)))
@@ -11454,7 +11454,7 @@ int QUICK_RANGE_SELECT::get_next_prefix(uint prefix_length,
         DBUG_RETURN(0);
     }
 
-    uint count= ranges.elements - (cur_range - (QUICK_RANGE**) ranges.buffer);
+    uint count= ranges.elements - (uint)(cur_range - (QUICK_RANGE**) ranges.buffer);
     if (count == 0)
     {
       /* Ranges have already been used up before. None is left for read. */
@@ -11499,7 +11499,7 @@ int QUICK_RANGE_SELECT_GEOM::get_next()
 	DBUG_RETURN(result);
     }
 
-    uint count= ranges.elements - (cur_range - (QUICK_RANGE**) ranges.buffer);
+    uint count= ranges.elements - (uint)(cur_range - (QUICK_RANGE**) ranges.buffer);
     if (count == 0)
     {
       /* Ranges have already been used up before. None is left for read. */
@@ -11953,7 +11953,7 @@ void QUICK_SELECT_I::add_key_and_length(String *key_names,
                                         bool *first)
 {
   char buf[64];
-  uint length;
+  size_t length;
   KEY *key_info= head->key_info + index;
 
   if (*first)
@@ -12507,7 +12507,7 @@ get_best_group_min_max(PARAM *param, SEL_TREE *tree, double read_time)
         {
           cur_group_prefix_len+= cur_part->store_length;
           ++cur_group_key_parts;
-          max_key_part= cur_part - cur_index_info->key_part + 1;
+          max_key_part= (uint)(cur_part - cur_index_info->key_part) + 1;
           used_key_parts_map.set_bit(max_key_part);
         }
         else
@@ -13230,7 +13230,7 @@ get_field_keypart(KEY *index, Field *field)
        part < end; part++)
   {
     if (field->eq(part->field))
-      return part - index->key_part + 1;
+      return (uint)(part - index->key_part + 1);
   }
   return 0;
 }
diff --git a/sql/opt_range_mrr.cc b/sql/opt_range_mrr.cc
index b3350191d13..ace6208fd77 100644
--- a/sql/opt_range_mrr.cc
+++ b/sql/opt_range_mrr.cc
@@ -199,9 +199,9 @@ walk_right_n_up:
   {
     {
       RANGE_SEQ_ENTRY *cur= &seq->stack[seq->i];
-      uint min_key_length= cur->min_key - seq->param->min_key;
-      uint max_key_length= cur->max_key - seq->param->max_key;
-      uint len= cur->min_key - cur[-1].min_key;
+      size_t min_key_length= cur->min_key - seq->param->min_key;
+      size_t max_key_length= cur->max_key - seq->param->max_key;
+      size_t len= cur->min_key - cur[-1].min_key;
       if (!(min_key_length == max_key_length &&
             !memcmp(cur[-1].min_key, cur[-1].max_key, len) &&
             !key_tree->min_flag && !key_tree->max_flag))
@@ -238,7 +238,7 @@ walk_up_n_right:
 
   /* Ok got a tuple */
   RANGE_SEQ_ENTRY *cur= &seq->stack[seq->i];
-  uint min_key_length= cur->min_key - seq->param->min_key;
+  uint min_key_length= (uint)(cur->min_key - seq->param->min_key);
   
   range->ptr= (char*)(intptr)(key_tree->part);
   if (cur->min_key_flag & GEOM_FLAG)
@@ -256,13 +256,13 @@ walk_up_n_right:
     range->range_flag= cur->min_key_flag | cur->max_key_flag;
     
     range->start_key.key=    seq->param->min_key;
-    range->start_key.length= cur->min_key - seq->param->min_key;
+    range->start_key.length= (uint)(cur->min_key - seq->param->min_key);
     range->start_key.keypart_map= make_prev_keypart_map(cur->min_key_parts);
     range->start_key.flag= (cur->min_key_flag & NEAR_MIN ? HA_READ_AFTER_KEY : 
                                                            HA_READ_KEY_EXACT);
 
     range->end_key.key=    seq->param->max_key;
-    range->end_key.length= cur->max_key - seq->param->max_key;
+    range->end_key.length= (uint)(cur->max_key - seq->param->max_key);
     range->end_key.flag= (cur->max_key_flag & NEAR_MAX ? HA_READ_BEFORE_KEY : 
                                                          HA_READ_AFTER_KEY);
     range->end_key.keypart_map= make_prev_keypart_map(cur->max_key_parts);
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index ab587b8b279..8a75aaed8d6 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -768,12 +768,12 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
   key_part_map org_key_part_used= *key_part_used;
   if (eq_type || between || max_fl == less_fl)
   {
-    uint length= (key_ptr-ref->key_buff)+part->store_length;
+    uint length= (uint)(key_ptr-ref->key_buff)+part->store_length;
     if (ref->key_length < length)
     {
     /* Ultimately ref->key_length will contain the length of the search key */
       ref->key_length= length;      
-      ref->key_parts= (part - keyinfo->key_part) + 1;
+      ref->key_parts= (uint)(part - keyinfo->key_part) + 1;
     }
     if (!*prefix_len && part+1 == field_part)       
       *prefix_len= length;
diff --git a/sql/opt_table_elimination.cc b/sql/opt_table_elimination.cc
index b7010d1f8ed..a480a1659e9 100644
--- a/sql/opt_table_elimination.cc
+++ b/sql/opt_table_elimination.cc
@@ -848,7 +848,7 @@ bool check_func_dependency(JOIN *join,
   */
   uint and_level=0;
   build_eq_mods_for_cond(join->thd, &dac, &last_eq_mod, &and_level, cond);
-  if (!(dac.n_equality_mods= last_eq_mod - dac.equality_mods))
+  if (!(dac.n_equality_mods= (uint)(last_eq_mod - dac.equality_mods)))
     return FALSE;  /* No useful conditions */
 
   List<Dep_module> bound_modules;
@@ -1061,7 +1061,7 @@ bool Dep_analysis_context::setup_equality_modules_deps(List<Dep_module>
        eq_mod < equality_mods + n_equality_mods;
        eq_mod++)
   {
-    deps_recorder.expr_offset= eq_mod - equality_mods;
+    deps_recorder.expr_offset= (uint)(eq_mod - equality_mods);
     deps_recorder.visited_other_tables= FALSE;
     eq_mod->unbound_args= 0;
     
@@ -1079,7 +1079,7 @@ bool Dep_analysis_context::setup_equality_modules_deps(List<Dep_module>
       Dep_value_field* field_val;
       while ((field_val= it++))
       {
-        uint offs= field_val->bitmap_offset + eq_mod - equality_mods;
+        uint offs= (uint)(field_val->bitmap_offset + eq_mod - equality_mods);
         bitmap_set_bit(&expr_deps, offs);
       }
     }
@@ -1158,7 +1158,7 @@ void build_eq_mods_for_cond(THD *thd, Dep_analysis_context *ctx,
   if (cond->type() == Item_func::COND_ITEM)
   {
     List_iterator_fast<Item> li(*((Item_cond*) cond)->argument_list());
-    uint orig_offset= *eq_mod - ctx->equality_mods;
+    size_t orig_offset= *eq_mod - ctx->equality_mods;
     
     /* AND/OR */
     if (((Item_cond*) cond)->functype() == Item_func::COND_AND_FUNC)
diff --git a/sql/parse_file.cc b/sql/parse_file.cc
index 0c44f6a9820..2aad3f38761 100644
--- a/sql/parse_file.cc
+++ b/sql/parse_file.cc
@@ -255,7 +255,7 @@ sql_create_definition_file(const LEX_STRING *dir, const LEX_STRING *file_name,
   File handler;
   IO_CACHE file;
   char path[FN_REFLEN+1];	// +1 to put temporary file name for sure
-  int path_end;
+  size_t path_end;
   File_option *param;
   DBUG_ENTER("sql_create_definition_file");
   DBUG_PRINT("enter", ("Dir: %s, file: %s, base %p",
diff --git a/sql/partition_info.cc b/sql/partition_info.cc
index 535ed4612e0..c2bc530117f 100644
--- a/sql/partition_info.cc
+++ b/sql/partition_info.cc
@@ -1673,7 +1673,7 @@ void partition_info::print_no_partition_found(TABLE *table_arg, myf errflag)
 bool partition_info::set_part_expr(THD *thd, char *start_token, Item *item_ptr,
                                    char *end_token, bool is_subpart)
 {
-  uint expr_len= end_token - start_token;
+  size_t expr_len= end_token - start_token;
   char *func_string= (char*) thd->memdup(start_token, expr_len);
 
   if (!func_string)
diff --git a/sql/rpl_record.cc b/sql/rpl_record.cc
index 3147baf7d73..dd4c952fa30 100644
--- a/sql/rpl_record.cc
+++ b/sql/rpl_record.cc
@@ -80,7 +80,7 @@ pack_row(TABLE *table, MY_BITMAP const* cols,
   unsigned int null_mask= 1U;
   for ( ; (field= *p_field) ; p_field++)
   {
-    if (bitmap_is_set(cols, p_field - table->field))
+    if (bitmap_is_set(cols, (uint)(p_field - table->field)))
     {
       my_ptrdiff_t offset;
       if (field->is_null(rec_offset))
@@ -262,7 +262,7 @@ unpack_row(rpl_group_info *rgi,
       No need to bother about columns that does not exist: they have
       gotten default values when being emptied above.
      */
-    if (bitmap_is_set(cols, field_ptr -  begin_ptr))
+    if (bitmap_is_set(cols, (uint)(field_ptr -  begin_ptr)))
     {
       if ((null_mask & 0xFF) == 0)
       {
@@ -434,7 +434,7 @@ unpack_row(rpl_group_info *rgi,
   if (master_reclength)
   {
     if (*field_ptr)
-      *master_reclength = (*field_ptr)->ptr - table->record[0];
+      *master_reclength = (ulong)((*field_ptr)->ptr - table->record[0]);
     else
       *master_reclength = table->s->reclength;
   }
diff --git a/sql/rpl_record_old.cc b/sql/rpl_record_old.cc
index 5b876373b9c..8e21c4a94a5 100644
--- a/sql/rpl_record_old.cc
+++ b/sql/rpl_record_old.cc
@@ -134,7 +134,7 @@ unpack_row_old(rpl_group_info *rgi,
   {
     Field *const f= *field_ptr;
 
-    if (bitmap_is_set(cols, field_ptr -  begin_ptr))
+    if (bitmap_is_set(cols, (uint)(field_ptr -  begin_ptr)))
     {
       f->move_field_offset(offset);
       ptr= f->unpack(f->ptr, ptr, row_buffer_end, 0);
@@ -149,14 +149,14 @@ unpack_row_old(rpl_group_info *rgi,
       }
     }
     else
-      bitmap_clear_bit(rw_set, field_ptr - begin_ptr);
+      bitmap_clear_bit(rw_set, (uint)(field_ptr - begin_ptr));
   }
 
   *row_end = ptr;
   if (master_reclength)
   {
     if (*field_ptr)
-      *master_reclength = (*field_ptr)->ptr - table->record[0];
+      *master_reclength = (ulong)((*field_ptr)->ptr - table->record[0]);
     else
       *master_reclength = table->s->reclength;
   }
diff --git a/sql/spatial.cc b/sql/spatial.cc
index 8817e82d6c4..357e311543f 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -2565,7 +2565,7 @@ uint Gis_multi_polygon::init_from_opresult(String *bin,
     n_poly++;
   }
   bin->write_at_position(np_pos, n_poly);
-  return opres - opres_orig;
+  return (uint)(opres - opres_orig);
 }
 
 
diff --git a/sql/sql_acl.cc b/sql/sql_acl.cc
index 819bdb8200a..af49eefa2a5 100644
--- a/sql/sql_acl.cc
+++ b/sql/sql_acl.cc
@@ -12341,7 +12341,7 @@ static bool parse_com_change_user_packet(MPVIO_EXT *mpvio, uint packet_length)
   char *end= user + packet_length;
   /* Safe because there is always a trailing \0 at the end of the packet */
   char *passwd= strend(user) + 1;
-  uint user_len= passwd - user - 1;
+  uint user_len= (uint)(passwd - user - 1);
   char *db= passwd;
   char db_buff[SAFE_NAME_LEN + 1];            // buffer to store db in utf8
   char user_buff[USERNAME_LENGTH + 1];	      // buffer to store user in utf8
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 9c752b4f882..ea57e1d19c9 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -5444,7 +5444,7 @@ find_field_in_table(THD *thd, TABLE *table, const char *name, uint length,
 
   if (field_ptr && *field_ptr)
   {
-    *cached_field_index_ptr= field_ptr - table->field;
+    *cached_field_index_ptr= (uint)(field_ptr - table->field);
     field= *field_ptr;
   }
   else
diff --git a/sql/sql_cache.cc b/sql/sql_cache.cc
index 9077af58d31..6727be69d07 100644
--- a/sql/sql_cache.cc
+++ b/sql/sql_cache.cc
@@ -4286,7 +4286,7 @@ my_bool Query_cache::move_by_type(uchar **border,
 		      *pprev = block->pprev,
 		      *pnext = block->pnext,
 		      *new_block =(Query_cache_block *) *border;
-    uint tablename_offset = block->table()->table() - block->table()->db();
+    size_t tablename_offset = block->table()->table() - block->table()->db();
     char *data = (char*) block->data();
     uchar *key;
     size_t key_length;
@@ -4595,7 +4595,7 @@ uint Query_cache::filename_2_table_key (char *key, const char *path,
   filename=  tablename + dirname_length(tablename + 2) + 2;
   /* Find start of databasename */
   for (dbname= filename - 2 ; dbname[-1] != FN_LIBCHAR ; dbname--) ;
-  *db_length= (filename - dbname) - 1;
+  *db_length= (uint32)(filename - dbname) - 1;
   DBUG_PRINT("qcache", ("table '%-.*s.%s'", *db_length, dbname, filename));
 
   DBUG_RETURN((uint) (strmake(strmake(key, dbname,
diff --git a/sql/sql_db.cc b/sql/sql_db.cc
index 813a17cdfdb..073e351d895 100644
--- a/sql/sql_db.cc
+++ b/sql/sql_db.cc
@@ -1018,7 +1018,7 @@ update_binlog:
           These DDL methods and logging are protected with the exclusive
           metadata lock on the schema.
         */
-        if (write_to_binlog(thd, query, query_pos -1 - query, db, db_len))
+        if (write_to_binlog(thd, query, (uint)(query_pos -1 - query), db, db_len))
         {
           error= true;
           goto exit;
@@ -1036,7 +1036,7 @@ update_binlog:
         These DDL methods and logging are protected with the exclusive
         metadata lock on the schema.
       */
-      if (write_to_binlog(thd, query, query_pos -1 - query, db, db_len))
+      if (write_to_binlog(thd, query, (uint)(query_pos -1 - query), db, db_len))
       {
         error= true;
         goto exit;
diff --git a/sql/sql_join_cache.cc b/sql/sql_join_cache.cc
index 41741f3dcc7..e6ef8a4be9f 100644
--- a/sql/sql_join_cache.cc
+++ b/sql/sql_join_cache.cc
@@ -406,7 +406,7 @@ void JOIN_CACHE::create_flag_fields()
   }
 
   /* Theoretically the new value of flag_fields can be less than the old one */   
-  flag_fields= copy-field_descr;
+  flag_fields= (uint)(copy-field_descr);
 }
 
 
@@ -1374,7 +1374,7 @@ uint JOIN_CACHE::write_record_data(uchar * link, bool *is_full)
     }
     /* Save the offset of the field to put it later at the end of the record */ 
     if (copy->referenced_field_no)
-      copy->offset= cp-curr_rec_pos;
+      copy->offset= (uint)(cp-curr_rec_pos);
 
     switch (copy->type) {
     case CACHE_BLOB:
@@ -1778,7 +1778,7 @@ uint JOIN_CACHE::read_flag_fields()
     memcpy(copy->str, pos, copy->length);
     pos+= copy->length;
   }
-  return (pos-init_pos);
+  return (uint)(pos-init_pos);
 }
 
 
diff --git a/sql/sql_repl.cc b/sql/sql_repl.cc
index e3a082b680d..848dce6d4ca 100644
--- a/sql/sql_repl.cc
+++ b/sql/sql_repl.cc
@@ -2681,7 +2681,7 @@ static int send_events(binlog_send_info *info, IO_CACHE* log, LOG_INFO* linfo,
       Gtid_list_log_event glev(&info->until_binlog_state, 0);
 
       if (reset_transmit_packet(info, info->flags, &ev_offset, &info->errmsg) ||
-          fake_gtid_list_event(info, &glev, &info->errmsg, my_b_tell(log)))
+          fake_gtid_list_event(info, &glev, &info->errmsg, (uint32)my_b_tell(log)))
       {
         info->error= ER_UNKNOWN_ERROR;
         return 1;
@@ -2691,7 +2691,7 @@ static int send_events(binlog_send_info *info, IO_CACHE* log, LOG_INFO* linfo,
 
     if (info->until_gtid_state &&
         is_until_reached(info, &ev_offset, event_type, &info->errmsg,
-                         my_b_tell(log)))
+                         (uint32)my_b_tell(log)))
     {
       if (info->errmsg)
       {
@@ -2746,7 +2746,7 @@ static int send_one_binlog_file(binlog_send_info *info,
     if (end_pos <= 1)
     {
       /** end of file or error */
-      return end_pos;
+      return (int)end_pos;
     }
 
     /**
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 0ce7ff958db..f4f0e46afed 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -6077,7 +6077,7 @@ double matching_candidates_in_table(JOIN_TAB *s, bool with_found_constraint,
   {
     TABLE *table= s->table;
     double sel= table->cond_selectivity;
-    double table_records= table->stat_records();
+    double table_records= (double)table->stat_records();
     dbl_records= table_records * sel;
     return dbl_records;
   }
@@ -6103,7 +6103,7 @@ double matching_candidates_in_table(JOIN_TAB *s, bool with_found_constraint,
   if (s->table->quick_condition_rows != s->found_records)
     records= s->table->quick_condition_rows;
 
-  dbl_records= records;
+  dbl_records= (double)records;
   return dbl_records;
 }
 
@@ -6794,7 +6794,7 @@ static void choose_initial_table_order(JOIN *join)
     if ((emb_subq= get_emb_subq(*tab)))
       break;
   }
-  uint n_subquery_tabs= tabs_end - tab;
+  uint n_subquery_tabs= (uint)(tabs_end - tab);
 
   if (!n_subquery_tabs)
     DBUG_VOID_RETURN;
@@ -6822,7 +6822,7 @@ static void choose_initial_table_order(JOIN *join)
            last_tab_for_subq < subq_tabs_end && 
            get_emb_subq(*last_tab_for_subq) == cur_subq_nest;
            last_tab_for_subq++) {}
-      uint n_subquery_tables= last_tab_for_subq - subq_tab;
+      uint n_subquery_tables= (uint)(last_tab_for_subq - subq_tab);
 
       /* 
         Walk the original array and find where this subquery would have been
@@ -6840,7 +6840,7 @@ static void choose_initial_table_order(JOIN *join)
         if (!need_tables)
         {
           /* Move away the top-level tables that are after top_level_tab */
-          uint top_tail_len= last_top_level_tab - top_level_tab - 1;
+          size_t top_tail_len= last_top_level_tab - top_level_tab - 1;
           memmove(top_level_tab + 1 + n_subquery_tables, top_level_tab + 1,
                   sizeof(JOIN_TAB*)*top_tail_len);
           last_top_level_tab += n_subquery_tables;
@@ -7586,7 +7586,7 @@ double JOIN::get_examined_rows()
   JOIN_TAB *tab= first_breadth_first_tab();
   JOIN_TAB *prev_tab= tab;
 
-  examined_rows= tab->get_examined_rows();
+  examined_rows= (double)tab->get_examined_rows();
 
   while ((tab= next_breadth_first_tab(first_breadth_first_tab(),
                                       top_join_tab_count, tab)))
@@ -7884,7 +7884,7 @@ double table_cond_selectivity(JOIN *join, uint idx, JOIN_TAB *s,
             }
             if (keyparts > 1)
 	    {
-              ref_keyuse_steps[keyparts-2]= keyuse - prev_ref_keyuse;
+              ref_keyuse_steps[keyparts-2]= (uint16)(keyuse - prev_ref_keyuse);
               prev_ref_keyuse= keyuse;
             }
           }
@@ -8984,8 +8984,8 @@ bool JOIN::get_best_combination()
       j= j->bush_root_tab;
   }
  
-  top_join_tab_count= join_tab_ranges.head()->end - 
-                      join_tab_ranges.head()->start;
+  top_join_tab_count= (uint)(join_tab_ranges.head()->end - 
+                      join_tab_ranges.head()->start);
 
   update_depend_map(this);
   DBUG_RETURN(0);
@@ -10561,7 +10561,7 @@ static uint make_join_orderinfo(JOIN *join)
   if (join->need_tmp)
     return join->table_count;
   tab= join->get_sort_by_join_tab();
-  return tab ? tab-join->join_tab : join->table_count;
+  return tab ? (uint)(tab-join->join_tab) : join->table_count;
 }
 
 /*
@@ -11578,8 +11578,8 @@ make_join_readinfo(JOIN *join, ulonglong options, uint no_jbuf_after)
                  str.append(" final_pushdown_cond");
                  print_where(tab->select_cond, str.c_ptr_safe(), QT_ORDINARY););
   }
-  uint n_top_tables= join->join_tab_ranges.head()->end -  
-                     join->join_tab_ranges.head()->start;
+  uint n_top_tables= (uint)(join->join_tab_ranges.head()->end -  
+                     join->join_tab_ranges.head()->start);
 
   join->join_tab[n_top_tables - 1].next_select=0;  /* Set by do_select */
   
@@ -11803,7 +11803,7 @@ ha_rows JOIN_TAB::get_examined_rows()
   SQL_SELECT *sel= filesort? filesort->select : this->select;
 
   if (sel && sel->quick && use_quick != 2)
-    examined_rows= sel->quick->records;
+    examined_rows= (double)sel->quick->records;
   else if (type == JT_NEXT || type == JT_ALL ||
            type == JT_HASH || type ==JT_HASH_NEXT)
   {
@@ -11813,19 +11813,19 @@ ha_rows JOIN_TAB::get_examined_rows()
         @todo This estimate is wrong, a LIMIT query may examine much more rows
         than the LIMIT itself.
       */
-      examined_rows= limit;
+      examined_rows= (double)limit;
     }
     else
     {
       if (table->is_filled_at_execution())
-        examined_rows= records;
+        examined_rows= (double)records;
       else
       {
         /*
           handler->info(HA_STATUS_VARIABLE) has been called in
           make_join_statistics()
         */
-        examined_rows= table->stat_records();
+        examined_rows= (double)table->stat_records();
       }
     }
   }
@@ -13624,7 +13624,7 @@ static int compare_fields_by_table_order(Item *field1,
       tab2= tab2->bush_root_tab;
   }
   
-  cmp= tab1 - tab2;
+  cmp= (int)(tab1 - tab2);
 
   if (!cmp)
   {
@@ -16845,7 +16845,7 @@ create_tmp_table(THD *thd, TMP_TABLE_PARAM *param, List<Item> &fields,
     share->default_values= table->record[1]+alloc_length;
   }
   copy_func[0]=0;				// End marker
-  param->func_count= copy_func - param->items_to_copy; 
+  param->func_count= (uint)(copy_func - param->items_to_copy); 
 
   setup_tmp_table_column_bitmaps(table, bitmaps);
 
@@ -17529,7 +17529,7 @@ bool create_internal_tmp_table(TABLE *table, KEY *keyinfo,
           Emulate behaviour by making column not-nullable when creating the
           table.
         */
-        uint cols= (*recinfo-start_recinfo);
+        uint cols= (uint)(*recinfo-start_recinfo);
         start_recinfo[cols-1].null_bit= 0;
       }
     }
@@ -20747,7 +20747,7 @@ static int test_if_order_by_key(JOIN *join,
        (1) this is an extended key
        (2) we've reached its end
     */
-    key_parts= (key_part - table->key_info[idx].key_part);
+    key_parts= (uint)(key_part - table->key_info[idx].key_part);
     if (have_pk_suffix &&
         reverse == 0 && // all were =const so far
         key_parts == table->key_info[idx].ext_key_parts && 
@@ -24386,7 +24386,7 @@ void JOIN_TAB::save_explain_data(Explain_table_access *eta,
   }
   else
   {
-    double examined_rows= get_examined_rows();
+    double examined_rows= (double)get_examined_rows();
 
     eta->rows_set= true;
     eta->rows= (ha_rows) examined_rows;
@@ -25757,8 +25757,8 @@ static bool get_range_limit_read_cost(const JOIN_TAB *tab,
       Start from quick select's rows and cost. These are always cheaper than
       full index scan/cost.
     */
-    double best_rows= table->quick_rows[keynr];
-    double best_cost= table->quick_costs[keynr];
+    double best_rows= (double)table->quick_rows[keynr];
+    double best_cost= (double)table->quick_costs[keynr];
     
     /*
       Check if ref(const) access was possible on this index. 
@@ -25792,7 +25792,7 @@ static bool get_range_limit_read_cost(const JOIN_TAB *tab,
 
         if (ref_rows > 0)
         {
-          double tmp= ref_rows;
+          double tmp= (double)ref_rows;
           /* Reuse the cost formula from best_access_path: */
           set_if_smaller(tmp, (double) tab->join->thd->variables.max_seeks_for_key);
           if (table->covering_keys.is_set(keynr))
@@ -25803,7 +25803,7 @@ static bool get_range_limit_read_cost(const JOIN_TAB *tab,
           if (tmp < best_cost)
           {
             best_cost= tmp;
-            best_rows= ref_rows;
+            best_rows= (double)ref_rows;
           }
         }
       }
@@ -25916,7 +25916,7 @@ test_if_cheaper_ordering(const JOIN_TAB *tab, ORDER *order, TABLE *table,
 
   if (join)
   {
-    uint tablenr= tab - join->join_tab;
+    uint tablenr= (uint)(tab - join->join_tab);
     read_time= join->best_positions[tablenr].read_time;
     for (uint i= tablenr+1; i < join->table_count; i++)
       fanout*= join->best_positions[i].records_read; // fanout is always >= 1
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 1ed1201489e..579cbcd878e 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -3369,7 +3369,7 @@ static bool show_status_array(THD *thd, const char *wild,
   prefix_end=strnmov(name_buffer, prefix, sizeof(name_buffer)-1);
   if (*prefix)
     *prefix_end++= '_';
-  len=name_buffer + sizeof(name_buffer) - prefix_end;
+  len=(int)(name_buffer + sizeof(name_buffer) - prefix_end);
 
 #ifdef WITH_WSREP
   bool is_wsrep_var= FALSE;
@@ -5363,7 +5363,7 @@ static void store_column_type(TABLE *table, Field *field, CHARSET_INFO *cs,
     */
     tmp_buff= strchr(column_type.c_ptr_safe(), ' ');
   table->field[offset]->store(column_type.ptr(),
-                              (tmp_buff ? tmp_buff - column_type.ptr() :
+                              (tmp_buff ? (uint)(tmp_buff - column_type.ptr()) :
                                column_type.length()), cs);
 
   is_blob= (field->type() == MYSQL_TYPE_BLOB);
@@ -6345,7 +6345,7 @@ static int get_schema_views_record(THD *thd, TABLE_LIST *tables,
         table->field[5]->store(STRING_WITH_LEN("NO"), cs);
     }
 
-    definer_len= (strxmov(definer, tables->definer.user.str, "@",
+    definer_len= (uint)(strxmov(definer, tables->definer.user.str, "@",
                           tables->definer.host.str, NullS) - definer);
     table->field[6]->store(definer, definer_len, cs);
     if (tables->view_suid)
diff --git a/sql/sql_statistics.cc b/sql/sql_statistics.cc
index 9c84729e1c2..5a9bf08d99b 100644
--- a/sql/sql_statistics.cc
+++ b/sql/sql_statistics.cc
@@ -843,7 +843,7 @@ public:
     else
     {
       stat_field->set_notnull();
-      stat_field->store(table->collected_stats->cardinality);
+      stat_field->store(table->collected_stats->cardinality,true);
     }
   }
 
@@ -1055,7 +1055,7 @@ public:
         switch (i) {
         case COLUMN_STAT_MIN_VALUE:
           if (table_field->type() == MYSQL_TYPE_BIT)
-            stat_field->store(table_field->collected_stats->min_value->val_int());
+            stat_field->store(table_field->collected_stats->min_value->val_int(),true);
           else
           {
             table_field->collected_stats->min_value->val_str(&val);
@@ -1064,7 +1064,7 @@ public:
           break;
         case COLUMN_STAT_MAX_VALUE:
           if (table_field->type() == MYSQL_TYPE_BIT)
-            stat_field->store(table_field->collected_stats->max_value->val_int());
+            stat_field->store(table_field->collected_stats->max_value->val_int(),true);
           else
           {
             table_field->collected_stats->max_value->val_str(&val);
@@ -1631,7 +1631,7 @@ public:
     of the parameters to be passed to the constructor of the Unique object. 
   */  
 
-  Count_distinct_field(Field *field, uint max_heap_table_size)
+  Count_distinct_field(Field *field, size_t max_heap_table_size)
   {
     table_field= field;
     tree_key_length= field->pack_length();
@@ -1729,7 +1729,7 @@ class Count_distinct_field_bit: public Count_distinct_field
 {
 public:
 
-  Count_distinct_field_bit(Field *field, uint max_heap_table_size)
+  Count_distinct_field_bit(Field *field, size_t max_heap_table_size)
   {
     table_field= field;
     tree_key_length= sizeof(ulonglong);
@@ -1825,7 +1825,7 @@ public:
     if ((calc_state=
          (Prefix_calc_state *) thd->alloc(sizeof(Prefix_calc_state)*key_parts)))
     {
-      uint keyno= key_info-table->key_info;
+      uint keyno= (uint)(key_info-table->key_info);
       for (i= 0, state= calc_state; i < key_parts; i++, state++)
       {
         /* 
@@ -2439,7 +2439,7 @@ int alloc_histograms_for_table_share(THD* thd, TABLE_SHARE *table_share,
 inline
 void Column_statistics_collected::init(THD *thd, Field *table_field)
 {
-  uint max_heap_table_size= thd->variables.max_heap_table_size;
+  size_t max_heap_table_size= (size_t)thd->variables.max_heap_table_size;
   TABLE *table= table_field->table;
   uint pk= table->s->primary_key;
   
@@ -3720,14 +3720,14 @@ double get_column_avg_frequency(Field * field)
   */
   if (!table->s->field)
   {
-    res= table->stat_records();
+    res= (double)table->stat_records();
     return res;
   }
  
   Column_statistics *col_stats= field->read_stats;
 
   if (!col_stats)
-    res= table->stat_records();
+    res= (double)table->stat_records();
   else
     res= col_stats->get_avg_frequency();
   return res;
@@ -3766,7 +3766,7 @@ double get_column_range_cardinality(Field *field,
   double res;
   TABLE *table= field->table;
   Column_statistics *col_stats= field->read_stats;
-  double tab_records= table->stat_records();
+  double tab_records= (double)table->stat_records();
 
   if (!col_stats)
     return tab_records;
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index de367eda992..db9340d7977 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -231,7 +231,7 @@ uint explain_filename(THD* thd,
   {
     db_name= table_name;
     /* calculate the length */
-    db_name_len= tmp_p - db_name;
+    db_name_len= (int)(tmp_p - db_name);
     tmp_p++;
     table_name= tmp_p;
   }
@@ -253,7 +253,7 @@ uint explain_filename(THD* thd,
     case 's':
       if ((tmp_p[1] == 'P' || tmp_p[1] == 'p') && tmp_p[2] == '#')
       {
-        part_name_len= tmp_p - part_name - 1;
+        part_name_len= (int)(tmp_p - part_name - 1);
         subpart_name= tmp_p + 3;
 	tmp_p+= 3;
       }
@@ -285,7 +285,7 @@ uint explain_filename(THD* thd,
   }
   if (part_name)
   {
-    table_name_len= part_name - table_name - 3;
+    table_name_len= (int)(part_name - table_name - 3);
     if (subpart_name)
       subpart_name_len= strlen(subpart_name);
     else
@@ -358,7 +358,7 @@ uint explain_filename(THD* thd,
       to_p= strnmov(to_p, " */", end_p - to_p);
   }
   DBUG_PRINT("exit", ("to '%s'", to));
-  DBUG_RETURN(to_p - to);
+  DBUG_RETURN((uint)(to_p - to));
 }
 
 
@@ -554,7 +554,7 @@ uint build_table_filename(char *buff, size_t bufflen, const char *db,
   pos= strxnmov(pos, end - pos, tbbuff, ext, NullS);
 
   DBUG_PRINT("exit", ("buff: '%s'", buff));
-  DBUG_RETURN(pos - buff);
+  DBUG_RETURN((uint)(pos - buff));
 }
 
 
@@ -2133,7 +2133,7 @@ static uint32 comment_length(THD *thd, uint32 comment_pos,
   for (query+= 3; query < query_end; query++)
   {
     if (query[-1] == '*' && query[0] == '/')
-      return (char*) query - *comment_start + 1;
+      return (uint32)((char*) query - *comment_start + 1);
   }
   return 0;
 }
@@ -2711,7 +2711,7 @@ bool quick_rm_table(THD *thd, handlerton *base, const char *db,
   bool error= 0;
   DBUG_ENTER("quick_rm_table");
 
-  uint path_length= table_path ?
+  size_t path_length= table_path ?
     (strxnmov(path, sizeof(path) - 1, table_path, reg_ext, NullS) - path) :
     build_table_filename(path, sizeof(path)-1, db, table_name, reg_ext, flags);
   if (mysql_file_delete(key_file_frm, path, MYF(0)))
@@ -6690,7 +6690,7 @@ static bool fill_alter_inplace_info(THD *thd,
       table_key;
     ha_alter_info->index_add_buffer
       [ha_alter_info->index_add_count++]=
-      new_key - ha_alter_info->key_info_buffer;
+      (uint)(new_key - ha_alter_info->key_info_buffer);
     /* Mark all old fields which are used in newly created index. */
     DBUG_PRINT("info", ("index changed: '%s'", table_key->name));
   }
@@ -6714,7 +6714,7 @@ static bool fill_alter_inplace_info(THD *thd,
       /* Key not found. Add the offset of the key to the add buffer. */
       ha_alter_info->index_add_buffer
         [ha_alter_info->index_add_count++]=
-        new_key - ha_alter_info->key_info_buffer;
+        (uint)(new_key - ha_alter_info->key_info_buffer);
       DBUG_PRINT("info", ("index added: '%s'", new_key->name));
     }
     else
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index feb99861c48..d16edf5b5d5 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -171,7 +171,7 @@ TEST_join(JOIN *join)
       in order not to garble the tabular output below.
     */
     String ref_key_parts[MAX_TABLES];
-    int tables_in_range= jt_range->end - jt_range->start;
+    int tables_in_range= (int)(jt_range->end - jt_range->start);
     for (i= 0; i < tables_in_range; i++)
     {
       JOIN_TAB *tab= jt_range->start + i;
diff --git a/sql/sql_time.cc b/sql/sql_time.cc
index cad4bae03e8..18ea4e8760b 100644
--- a/sql/sql_time.cc
+++ b/sql/sql_time.cc
@@ -274,7 +274,7 @@ to_ascii(CHARSET_INFO *cs,
     *dst++= static_cast<char>(wc);
   }
   *dst= '\0';
-  return dst - dst0;
+  return (uint)(dst - dst0);
 }
 
 
diff --git a/sql/sql_update.cc b/sql/sql_update.cc
index 4488435491e..b1069efbbc8 100644
--- a/sql/sql_update.cc
+++ b/sql/sql_update.cc
@@ -80,7 +80,7 @@ bool compare_record(const TABLE *table)
       {
         if (field->real_maybe_null())
         {
-          uchar null_byte_index= field->null_ptr - table->record[0];
+          uchar null_byte_index= (uchar)(field->null_ptr - table->record[0]);
           
           if (((table->record[0][null_byte_index]) & field->null_bit) !=
               ((table->record[1][null_byte_index]) & field->null_bit))
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index e994ec5f2a5..ded0332bc53 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -565,8 +565,8 @@ create_item_for_sp_var(THD *thd, LEX_STRING name, sp_variable *spvar,
   DBUG_ASSERT(spc && spvar);
 
   /* Position and length of the SP variable name in the query. */
-  pos_in_q= start_in_q - lex->sphead->m_tmp_query;
-  len_in_q= end_in_q - start_in_q;
+  pos_in_q= (uint)(start_in_q - lex->sphead->m_tmp_query);
+  len_in_q= (uint)(end_in_q - start_in_q);
 
   item= new (thd->mem_root)
     Item_splocal(thd, name, spvar->offset, spvar->sql_type(),
@@ -11836,8 +11836,8 @@ limit_option:
           {
             splocal= new (thd->mem_root)
               Item_splocal(thd, $1, spv->offset, spv->sql_type(),
-                  lip->get_tok_start() - lex->sphead->m_tmp_query,
-                  lip->get_ptr() - lip->get_tok_start());
+                  (uint)(lip->get_tok_start() - lex->sphead->m_tmp_query),
+                  (uint)(lip->get_ptr() - lip->get_tok_start()));
             if (splocal == NULL)
               MYSQL_YYABORT;
 #ifndef DBUG_OFF
@@ -13834,8 +13834,8 @@ param_marker:
               my_yyabort_error((ER_VIEW_SELECT_VARIABLE, MYF(0)));
             const char *query_start= lex->sphead ? lex->sphead->m_tmp_query
                                                  : thd->query();
-            item= new (thd->mem_root) Item_param(thd, lip->get_tok_start() -
-                                                      query_start);
+            item= new (thd->mem_root) Item_param(thd, (uint)(lip->get_tok_start() -
+                                                      query_start));
             if (!($$= item) || lex->param_list.push_back(item, thd->mem_root))
               my_yyabort_error((ER_OUT_OF_RESOURCES, MYF(0)));
           }
@@ -14130,8 +14130,8 @@ simple_ident:
               Item_splocal *splocal;
               splocal= new (thd->mem_root)
                          Item_splocal(thd, $1, spv->offset, spv->sql_type(),
-                                      lip->get_tok_start_prev() - lex->sphead->m_tmp_query,
-                                      lip->get_tok_end() - lip->get_tok_start_prev());
+                                      (uint)(lip->get_tok_start_prev() - lex->sphead->m_tmp_query),
+                                      (uint)(lip->get_tok_end() - lip->get_tok_start_prev()));
               if (splocal == NULL)
                 MYSQL_YYABORT;
 #ifndef DBUG_OFF
diff --git a/sql/strfunc.cc b/sql/strfunc.cc
index 4928e939e27..e1b4dc8227f 100644
--- a/sql/strfunc.cc
+++ b/sql/strfunc.cc
@@ -339,7 +339,7 @@ int find_string_in_array(LEX_STRING * const haystack, LEX_STRING * const needle,
     if (!cs->coll->strnncollsp(cs, (uchar *) pos->str, pos->length,
                                (uchar *) needle->str, needle->length))
     {
-      return (pos - haystack);
+      return (int)(pos - haystack);
     }
   return -1;
 }
diff --git a/sql/sys_vars.cc b/sql/sys_vars.cc
index 9f5dfa2d3a9..2bbd0c14f55 100644
--- a/sql/sys_vars.cc
+++ b/sql/sys_vars.cc
@@ -1469,7 +1469,7 @@ static Sys_var_ulonglong Sys_max_heap_table_size(
        "max_heap_table_size",
        "Don't allow creation of heap tables bigger than this",
        SESSION_VAR(max_heap_table_size), CMD_LINE(REQUIRED_ARG),
-       VALID_RANGE(16384, (ulonglong)~(intptr)0), DEFAULT(16*1024*1024),
+       VALID_RANGE(16384, SIZE_T_MAX), DEFAULT(16*1024*1024),
        BLOCK_SIZE(1024));
 
 static ulong mdl_locks_cache_size;
diff --git a/sql/table.cc b/sql/table.cc
index 2f403de9888..352c6c77691 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -2505,7 +2505,7 @@ int TABLE_SHARE::init_from_binary_frm_image(THD *thd, bool write,
     the correct null_bytes can now be set, since bitfields have been taken
     into account
   */
-  share->null_bytes= (null_pos - (uchar*) null_flags +
+  share->null_bytes= (uint)(null_pos - (uchar*) null_flags +
                       (null_bit_pos + 7) / 8);
   share->last_null_bit_pos= null_bit_pos;
   share->null_bytes_for_compare= null_bits_are_used ? share->null_bytes : 0;
@@ -6001,8 +6001,8 @@ Field_iterator_table_ref::get_or_create_column_ref(THD *thd, TABLE_LIST *parent_
     /* The field belongs to a merge view or information schema table. */
     Field_translator *translated_field= view_field_it.field_translator();
     nj_col= new Natural_join_column(translated_field, table_ref);
-    field_count= table_ref->field_translation_end -
-                 table_ref->field_translation;
+    field_count= (uint)(table_ref->field_translation_end -
+                 table_ref->field_translation);
   }
   else
   {