diff --git a/mysql-test/suite/galera/disabled.def b/mysql-test/suite/galera/disabled.def
index 8db0073d268..b9678d643e6 100644
--- a/mysql-test/suite/galera/disabled.def
+++ b/mysql-test/suite/galera/disabled.def
@@ -65,3 +65,4 @@ galera_ist_progress: MDEV-15236 galera_ist_progress fails when trying to read tr
 galera_gtid : MDEV-13549 Galera test failures 10.1
 galera_gtid_slave : MDEV-13549 Galera test failures 10.1
 galera_unicode_identifiers : MDEV-13549 Galera test failures 10.1
+galera.MW-86-wait1 : lock timeout in 10.3
diff --git a/mysys/my_bitmap.c b/mysys/my_bitmap.c
index b6963739613..4db6b8a44f8 100644
--- a/mysys/my_bitmap.c
+++ b/mysys/my_bitmap.c
@@ -174,6 +174,7 @@ my_bool my_bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
                        my_bool thread_safe)
 {
   DBUG_ENTER("my_bitmap_init");
+  map->mutex= 0;
   if (!buf)
   {
     uint size_in_bytes= bitmap_buffer_size(n_bits);
@@ -183,7 +184,6 @@ my_bool my_bitmap_init(MY_BITMAP *map, my_bitmap_map *buf, uint n_bits,
       size_in_bytes= ALIGN_SIZE(size_in_bytes);
       extra= sizeof(mysql_mutex_t);
     }
-    map->mutex= 0;
     if (!(buf= (my_bitmap_map*) my_malloc(size_in_bytes+extra, MYF(MY_WME))))
       DBUG_RETURN(1);
     if (thread_safe)
diff --git a/sql/item.cc b/sql/item.cc
index 215c1450a3c..01adae7cd40 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -965,6 +965,29 @@ bool Item_field::register_field_in_write_map(void *arg)
   return 0;
 }
 
+bool Item_field::mark_field_in_bitmap(void *arg)
+{
+  struct func_mark_field_processor *marker= (func_mark_field_processor*) arg;
+  ST_FIELD_INFO *fields= marker->fields;
+  MY_BITMAP *bitmap= &marker->bitmap;
+  uint count;
+  DBUG_ENTER("Item_field::mark_field_in_bitmap");
+
+  for (count=0; fields->field_name; fields++, count++)
+  {
+    if (!my_strcasecmp(system_charset_info, fields->field_name,
+                       field_name.str))
+    {
+      bitmap_set_bit(bitmap, count);
+      DBUG_RETURN(0);
+    }
+    /* Item_field can be '*' as this function is called before fix_fields */
+    if (field_name.str == star_clex_str.str)
+      bitmap_set_all(bitmap);
+  }
+  DBUG_RETURN(FALSE);
+}
+
 /**
   Check that we are not refering to any not yet initialized fields
 
diff --git a/sql/item.h b/sql/item.h
index 06720a33cf8..5c770d4129e 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1733,6 +1733,12 @@ class Item: public Value_source,
   virtual bool check_valid_arguments_processor(void *arg) { return 0; }
   virtual bool update_vcol_processor(void *arg) { return 0; }
   virtual bool set_fields_as_dependent_processor(void *arg) { return 0; }
+  struct func_mark_field_processor
+  {
+    ST_FIELD_INFO *fields;
+    MY_BITMAP bitmap;
+  };
+  virtual bool mark_field_in_bitmap(void *arg) { return 0; }
   /*============== End of Item processor list ======================*/
 
   virtual Item *get_copy(THD *thd)=0;
@@ -3022,6 +3028,7 @@ class Item_field :public Item_ident,
     }
     return 0;
   }
+  bool mark_field_in_bitmap(void *arg);
   void cleanup();
   Item_equal *get_item_equal() { return item_equal; }
   void set_item_equal(Item_equal *item_eq) { item_equal= item_eq; }
diff --git a/sql/set_var.cc b/sql/set_var.cc
index 1bdbd4e1f6e..f4d916119d2 100644
--- a/sql/set_var.cc
+++ b/sql/set_var.cc
@@ -1081,7 +1081,7 @@ int fill_sysvars(THD *thd, TABLE_LIST *tables, COND *cond)
   DBUG_ASSERT(tables->table->in_use == thd);
 
   cond= make_cond_for_info_schema(thd, cond, tables);
-  thd->count_cuted_fields= CHECK_FIELD_WARN;
+  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
   mysql_prlock_rdlock(&LOCK_system_variables_hash);
 
   for (uint i= 0; i < system_variable_hash.records; i++)
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 545f8111237..21e0162fe52 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -3656,7 +3656,7 @@ static bool show_status_array(THD *thd, const char *wild,
   CHARSET_INFO *charset= system_charset_info;
   DBUG_ENTER("show_status_array");
 
-  thd->count_cuted_fields= CHECK_FIELD_WARN;
+  thd->count_cuted_fields= CHECK_FIELD_IGNORE;
 
   prefix_end=strnmov(name_buffer, prefix, sizeof(name_buffer)-1);
   if (*prefix)
@@ -8064,6 +8064,49 @@ ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx)
   return &schema_tables[schema_table_idx];
 }
 
+static void
+mark_all_fields_used_in_query(THD *thd,
+                              struct Item::func_mark_field_processor *marker)
+{
+  Item *item;
+  ORDER *order;
+  SELECT_LEX *select_lex= &thd->lex->select_lex;
+  List_iterator<Item> it(select_lex->item_list);
+  DBUG_ENTER("mark_all_fields_used_in_query");
+
+  /* If not SELECT command, return all columns */
+  if (thd->lex->sql_command != SQLCOM_SELECT)
+  {
+    bitmap_set_all(&marker->bitmap);
+    DBUG_VOID_RETURN;
+  }
+
+  /* select fields list check */
+  while ((item= it++))
+    item->walk(&Item::mark_field_in_bitmap, 1, marker);
+  
+  /* select fields where cond check */
+  if (select_lex->where)
+    select_lex->where->walk(&Item::mark_field_in_bitmap, 1, marker);
+
+  /* select fields having cond check */
+  if (select_lex->having)
+    select_lex->having->walk(&Item::mark_field_in_bitmap, 1, marker);
+
+  for (order= select_lex->order_list.first ; order; order= order->next)
+    (*order->item)->walk(&Item::mark_field_in_bitmap, 1, marker);
+
+  for (order= select_lex->group_list.first ; order; order= order->next)
+    (*order->item)->walk(&Item::mark_field_in_bitmap, 1, marker);
+
+  /* Walk trough all tables and check the ON condition */
+  for (TABLE_LIST *table= thd->lex->query_tables;
+       table ;
+       table= table->next_global)
+    if (table->on_expr)
+      table->on_expr->walk(&Item::mark_field_in_bitmap, 1, marker);
+  DBUG_VOID_RETURN;
+}
 
 /**
   Create information_schema table using schema_table data.
@@ -8088,17 +8131,28 @@ ST_SCHEMA_TABLE *get_schema_table(enum enum_schema_tables schema_table_idx)
 
 TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
 {
-  int field_count= 0;
+  uint field_count;
   Item *item;
   TABLE *table;
   List<Item> field_list;
   ST_SCHEMA_TABLE *schema_table= table_list->schema_table;
   ST_FIELD_INFO *fields_info= schema_table->fields_info;
+  ST_FIELD_INFO *fields;
   CHARSET_INFO *cs= system_charset_info;
   MEM_ROOT *mem_root= thd->mem_root;
+  my_bitmap_map *buf;
+  struct Item::func_mark_field_processor marker;
   DBUG_ENTER("create_schema_table");
 
-  for (; fields_info->field_name; fields_info++)
+  for (field_count= 0, fields= fields_info; fields->field_name; fields++)
+    field_count++;
+  marker.fields= fields_info;
+  if (!(buf= (my_bitmap_map*) thd->alloc(bitmap_buffer_size(field_count))))
+    DBUG_RETURN(NULL);
+  my_bitmap_init(&marker.bitmap, buf, field_count, 0);
+  mark_all_fields_used_in_query(thd, &marker);
+
+  for (field_count=0; fields_info->field_name; fields_info++)
   {
     size_t field_name_length= strlen(fields_info->field_name);
     switch (fields_info->field_type) {
@@ -8175,19 +8229,35 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
     case MYSQL_TYPE_MEDIUM_BLOB:
     case MYSQL_TYPE_LONG_BLOB:
     case MYSQL_TYPE_BLOB:
-      if (!(item= new (mem_root)
-            Item_blob(thd, fields_info->field_name,
-                      fields_info->field_length)))
+      if (bitmap_is_set(&marker.bitmap, field_count))
       {
-        DBUG_RETURN(0);
+        if (!(item= new (mem_root)
+              Item_blob(thd, fields_info->field_name,
+                        fields_info->field_length)))
+        {
+          DBUG_RETURN(0);
+        }
+      }
+      else
+      {
+        if (!(item= new (mem_root)
+              Item_empty_string(thd, "", 1, cs)))
+        {
+          DBUG_RETURN(0);
+        }
+        item->set_name(thd, fields_info->field_name,
+                       field_name_length, cs);
       }
       break;
     default:
+    {
+      bool show_field;
       /* Don't let unimplemented types pass through. Could be a grave error. */
       DBUG_ASSERT(fields_info->field_type == MYSQL_TYPE_STRING);
 
+      show_field= bitmap_is_set(&marker.bitmap, field_count);
       if (!(item= new (mem_root)
-            Item_empty_string(thd, "", fields_info->field_length, cs)))
+            Item_empty_string(thd, "", show_field ? fields_info->field_length : 1, cs)))
       {
         DBUG_RETURN(0);
       }
@@ -8195,6 +8265,7 @@ TABLE *create_schema_table(THD *thd, TABLE_LIST *table_list)
                      field_name_length, cs);
       break;
     }
+    }
     field_list.push_back(item, thd->mem_root);
     item->maybe_null= (fields_info->field_flags & MY_I_S_MAYBE_NULL);
     field_count++;
