Change bitfields in Item to an uint16

The reason for the change is that neither clang or gcc can do efficient
code when several bit fields are change at the same time or when copying
one or more bits between identical bit fields.
Updated bits explicitely with & and | is MUCH more efficient than what
current compilers can do.

1 files changed, 52 insertions, 53 deletions

diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index a47ef297a7f..48f18ecd64f 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -1233,9 +1233,9 @@ JOIN::prepare(TABLE_LIST *tables_init, COND *conds_init, uint og_num,
 
     while ((select_el= select_it++))
     {
-      if (select_el->with_sum_func)
+      if (select_el->with_sum_func())
         found_sum_func_elem= true;
-      if (select_el->with_field)
+      if (select_el->with_field())
         found_field_elem= true;
       if (found_sum_func_elem && found_field_elem)
       {
@@ -1361,7 +1361,7 @@ JOIN::prepare(TABLE_LIST *tables_init, COND *conds_init, uint og_num,
       DBUG_RETURN(-1);				/* purecov: inspected */
     thd->lex->allow_sum_func= save_allow_sum_func;
 
-    if (having->with_window_func)
+    if (having->with_window_func())
     {
       my_error(ER_WRONG_PLACEMENT_OF_WINDOW_FUNCTION, MYF(0));
       DBUG_RETURN(-1); 
@@ -1379,7 +1379,7 @@ JOIN::prepare(TABLE_LIST *tables_init, COND *conds_init, uint og_num,
     Item *item;
     while ((item= it++))
     {
-      if (item->with_window_func)
+      if (item->with_window_func())
         item->update_used_tables();
     }
   }
@@ -1437,13 +1437,13 @@ JOIN::prepare(TABLE_LIST *tables_init, COND *conds_init, uint og_num,
             ((Item_field *) item)->field->sort_length()) &&
            /* AND not a zero length NOT NULL string function. */
            (item->type() != Item::FUNC_ITEM ||
-            item->maybe_null ||
+            item->maybe_null() ||
             item->result_type() != STRING_RESULT ||
             item->max_length)))
         requires_sorting= TRUE;
 
-      if ((item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM) ||
-          item->with_window_func)
+      if ((item->with_sum_func() && item->type() != Item::SUM_FUNC_ITEM) ||
+          item->with_window_func())
         item->split_sum_func(thd, ref_ptrs, all_fields, SPLIT_SUM_SELECT);
     }
     /* Drop the ORDER BY clause if none of the columns contain any data that
@@ -1461,7 +1461,7 @@ JOIN::prepare(TABLE_LIST *tables_init, COND *conds_init, uint og_num,
     }
   }
 
-  if (having && having->with_sum_func)
+  if (having && having->with_sum_func())
     having->split_sum_func2(thd, ref_ptrs, all_fields,
                             &having, SPLIT_SUM_SKIP_REGISTERED);
   if (select_lex->inner_sum_func_list)
@@ -2927,7 +2927,7 @@ int JOIN::optimize_stage2()
     elements may be lost during further having
     condition transformation in JOIN::exec.
   */
-  if (having && const_table_map && !having->with_sum_func)
+  if (having && const_table_map && !having->with_sum_func())
   {
     having->update_used_tables();
     having= having->remove_eq_conds(thd, &select_lex->having_value, true);
@@ -6195,7 +6195,7 @@ add_key_field(JOIN *join,
   {
     if ((cond->functype() == Item_func::EQ_FUNC ||
          cond->functype() == Item_func::MULT_EQUAL_FUNC) &&
-        ((*value)->maybe_null || field->real_maybe_null()))
+        ((*value)->maybe_null() || field->real_maybe_null()))
       (*key_fields)->null_rejecting= true;
     else
       (*key_fields)->null_rejecting= false;
@@ -7642,7 +7642,7 @@ best_access_path(JOIN      *join,
             if (!(keyuse->used_tables & ~join->const_table_map))
               const_part|= keyuse->keypart_map;
 
-            if (!keyuse->val->maybe_null || keyuse->null_rejecting)
+            if (!keyuse->val->maybe_null() || keyuse->null_rejecting)
               notnull_part|=keyuse->keypart_map;
 
             double tmp2= prev_record_reads(join_positions, idx,
@@ -10984,7 +10984,7 @@ static bool create_ref_for_key(JOIN *join, JOIN_TAB *j,
       j->ref.items[i]=keyuse->val;		// Save for cond removal
       j->ref.cond_guards[i]= keyuse->cond_guard;
 
-      if (!keyuse->val->maybe_null || keyuse->null_rejecting)
+      if (!keyuse->val->maybe_null() || keyuse->null_rejecting)
         not_null_keyparts++;
       /*
         Set ref.null_rejecting to true only if we are going to inject a
@@ -14290,7 +14290,7 @@ static void update_depend_map_for_order(JOIN *join, ORDER *order)
     order->used= 0;
     // Not item_sum(), RAND() and no reference to table outside of sub select
     if (!(order->depend_map & (OUTER_REF_TABLE_BIT | RAND_TABLE_BIT))
-        && !order->item[0]->with_sum_func &&
+        && !order->item[0]->with_sum_func() &&
         join->join_tab)
     {
       for (JOIN_TAB **tab=join->map2table;
@@ -14397,8 +14397,8 @@ remove_const(JOIN *join,ORDER *first_order, COND *cond,
   for (order=first_order; order ; order=order->next)
   {
     table_map order_tables=order->item[0]->used_tables();
-    if (order->item[0]->with_sum_func ||
-        order->item[0]->with_window_func ||
+    if (order->item[0]->with_sum_func() ||
+        order->item[0]->with_window_func() ||
         /*
           If the outer table of an outer join is const (either by itself or
           after applying WHERE condition), grouping on a field from such a
@@ -14545,7 +14545,7 @@ ORDER *simple_remove_const(ORDER *order, COND *where)
   ORDER *first= NULL, *prev= NULL;
   for (; order; order= order->next)
   {
-    DBUG_ASSERT(!order->item[0]->with_sum_func); // should never happen
+    DBUG_ASSERT(!order->item[0]->with_sum_func()); // should never happen
     if (!const_expression_in_where(where, order->item[0]))
     {
       if (!first)
@@ -17756,7 +17756,7 @@ Item_bool_func2::remove_eq_conds(THD *thd, Item::cond_result *cond_value,
     if (args[0]->eq(args[1], true))
     {
       if (*cond_value == Item::COND_FALSE ||
-          !args[0]->maybe_null || functype() == Item_func::EQUAL_FUNC)
+          !args[0]->maybe_null() || functype() == Item_func::EQUAL_FUNC)
         return (COND*) 0;                       // Compare of identical items
     }
   }
@@ -18049,7 +18049,7 @@ Field *Item::create_tmp_field_int(MEM_ROOT *root, TABLE *table,
     h= &type_handler_slonglong;
   if (unsigned_flag)
     h= h->type_handler_unsigned();
-  return h->make_and_init_table_field(root, &name, Record_addr(maybe_null),
+  return h->make_and_init_table_field(root, &name, Record_addr(maybe_null()),
                                       *this, table);
 }
 
@@ -18083,7 +18083,7 @@ Field *Item_sum::create_tmp_field(MEM_ROOT *root, bool group, TABLE *table)
   case REAL_RESULT:
   {
     new_field= new (root)
-      Field_double(max_char_length(), maybe_null, &name, decimals, TRUE);
+      Field_double(max_char_length(), maybe_null(), &name, decimals, TRUE);
     break;
   }
   case INT_RESULT:
@@ -18119,9 +18119,9 @@ Item_field::create_tmp_field_from_item_field(MEM_ROOT *root, TABLE *new_table,
     If item have to be able to store NULLs but underlaid field can't do it,
     create_tmp_field_from_field() can't be used for tmp field creation.
   */
-  if (((maybe_null && in_rollup) ||
+  if (((maybe_null() && in_rollup()) ||
       (new_table->in_use->create_tmp_table_for_derived && /* for mat. view/dt */
-       orig_item && orig_item->maybe_null)) &&
+       orig_item && orig_item->maybe_null())) &&
       !field->maybe_null())
   {
     /*
@@ -18130,7 +18130,7 @@ Item_field::create_tmp_field_from_item_field(MEM_ROOT *root, TABLE *new_table,
       when the outer query decided at some point after name resolution phase
       that this field might be null. Take this into account here.
     */
-    Record_addr rec(orig_item ? orig_item->maybe_null : maybe_null);
+    Record_addr rec(orig_item ? orig_item->maybe_null() : maybe_null());
     const Type_handler *handler= type_handler()->
                                    type_handler_for_tmp_table(this);
     result= handler->make_and_init_table_field(root,
@@ -18143,13 +18143,13 @@ Item_field::create_tmp_field_from_item_field(MEM_ROOT *root, TABLE *new_table,
     const Type_handler *handler=
       Type_handler::type_handler_long_or_longlong(max_char_length(), true);
     result= handler->make_and_init_table_field(root, &name,
-                                               Record_addr(maybe_null),
+                                               Record_addr(maybe_null()),
                                                *this, new_table);
   }
   else
   {
     LEX_CSTRING *tmp= orig_item ? &orig_item->name : &name;
-    bool tmp_maybe_null= param->modify_item() ? maybe_null :
+    bool tmp_maybe_null= param->modify_item() ? maybe_null() :
                                                 field->maybe_null();
     result= field->create_tmp_field(root, new_table, tmp_maybe_null);
     if (result)
@@ -18251,13 +18251,13 @@ Item_result_field::create_tmp_field_ex_from_handler(
     - Item_func
     - Item_subselect
   */
-  DBUG_ASSERT(fixed);
+  DBUG_ASSERT(fixed());
   DBUG_ASSERT(is_result_field());
   DBUG_ASSERT(type() != NULL_ITEM);
   get_tmp_field_src(src, param);
   Field *result;
   if ((result= h->make_and_init_table_field(root, &name,
-                                            Record_addr(maybe_null),
+                                            Record_addr(maybe_null()),
                                             *this, table)) &&
       param->modify_item())
     result_field= result;
@@ -18644,7 +18644,7 @@ bool Create_tmp_table::add_fields(THD *thd,
   Item *item;
   Field **tmp_from_field= m_from_field;
   while (!m_with_cycle && (item= li++))
-    if (item->is_in_with_cycle)
+    if (item->is_in_with_cycle())
     {
       m_with_cycle= true;
       /*
@@ -18662,7 +18662,7 @@ bool Create_tmp_table::add_fields(THD *thd,
     uint uneven_delta;
     current_counter= (((param->hidden_field_count < (fieldnr + 1)) &&
                        distinct_record_structure &&
-                       (!m_with_cycle || item->is_in_with_cycle)) ?
+                       (!m_with_cycle || item->is_in_with_cycle())) ?
                       distinct :
                       other);
     Item::Type type= item->type();
@@ -18673,7 +18673,7 @@ bool Create_tmp_table::add_fields(THD *thd,
     }
     if (not_all_columns)
     {
-      if (item->with_sum_func && type != Item::SUM_FUNC_ITEM)
+      if (item->with_sum_func() && type != Item::SUM_FUNC_ITEM)
       {
         if (item->used_tables() & OUTER_REF_TABLE_BIT)
           item->update_used_tables();
@@ -18730,7 +18730,7 @@ bool Create_tmp_table::add_fields(THD *thd,
               new_field->maybe_null() is still false, it will be
               changed below. But we have to setup Item_field correctly
             */
-            arg->maybe_null=1;
+            arg->flags|= ITEM_FLAG_MAYBE_NULL;
           }
           if (current_counter == distinct)
             new_field->flags|= FIELD_PART_OF_TMP_UNIQUE;
@@ -18806,7 +18806,7 @@ bool Create_tmp_table::add_fields(THD *thd,
       m_field_count[current_counter]++;
       m_uneven_bit[current_counter]+= (m_uneven_bit_length - uneven_delta);
 
-      if (item->marker == 4 && item->maybe_null)
+      if (item->marker == 4 && item->maybe_null())
       {
         m_group_null_items++;
         new_field->flags|= GROUP_FLAG;
@@ -19103,7 +19103,7 @@ bool Create_tmp_table::finalize(THD *thd,
     {
       Field *field=(*cur_group->item)->get_tmp_table_field();
       DBUG_ASSERT(field->table == table);
-      bool maybe_null=(*cur_group->item)->maybe_null;
+      bool maybe_null=(*cur_group->item)->maybe_null();
       m_key_part_info->null_bit=0;
       m_key_part_info->field=  field;
       m_key_part_info->fieldnr= field->field_index + 1;
@@ -19131,7 +19131,8 @@ bool Create_tmp_table::finalize(THD *thd,
             We solve this by marking the item as !maybe_null to ensure
             that the key,field and item definition match.
           */
-          (*cur_group->item)->maybe_null= maybe_null= 0;
+          maybe_null= 0;
+          (*cur_group->item)->flags&= (Item::item_flags_t) ~ITEM_FLAG_MAYBE_NULL;
         }
 
 	if (!(cur_group->field= field->new_key_field(thd->mem_root,table,
@@ -22397,7 +22398,7 @@ end_update(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
     }
     item->save_org_in_field(group->field, group->fast_field_copier_func);
     /* Store in the used key if the field was 0 */
-    if (item->maybe_null)
+    if (item->maybe_null())
       group->buff[-1]= (char) group->field->is_null();
   }
   if (!table->file->ha_index_read_map(table->record[1],
@@ -24777,14 +24778,14 @@ int setup_order(THD *thd, Ref_ptr_array ref_pointer_array, TABLE_LIST *tables,
     if (find_order_in_list(thd, ref_pointer_array, tables, order, fields,
                            all_fields, false, true, from_window_spec))
       return 1;
-    if ((*order->item)->with_window_func &&
+    if ((*order->item)->with_window_func() &&
         context_analysis_place != IN_ORDER_BY)
     {
       my_error(ER_WINDOW_FUNCTION_IN_WINDOW_SPEC, MYF(0));
       return 1;
     }
 
-    if (!(*order->item)->with_sum_func)
+    if (!(*order->item)->with_sum_func())
       continue;
 
     /*
@@ -24855,12 +24856,12 @@ setup_group(THD *thd, Ref_ptr_array ref_pointer_array, TABLE_LIST *tables,
                            all_fields, true, true, from_window_spec))
       return 1;
     (*ord->item)->marker= UNDEF_POS;		/* Mark found */
-    if ((*ord->item)->with_sum_func && context_analysis_place == IN_GROUP_BY)
+    if ((*ord->item)->with_sum_func() && context_analysis_place == IN_GROUP_BY)
     {
       my_error(ER_WRONG_GROUP_FIELD, MYF(0), (*ord->item)->full_name());
       return 1;
     }
-    if ((*ord->item)->with_window_func)
+    if ((*ord->item)->with_window_func())
     {
       if (context_analysis_place == IN_GROUP_BY)
         my_error(ER_WRONG_PLACEMENT_OF_WINDOW_FUNCTION, MYF(0));
@@ -24868,7 +24869,7 @@ setup_group(THD *thd, Ref_ptr_array ref_pointer_array, TABLE_LIST *tables,
         my_error(ER_WINDOW_FUNCTION_IN_WINDOW_SPEC, MYF(0));
       return 1;
     }
-    if (from_window_spec && (*ord->item)->with_sum_func &&
+    if (from_window_spec && (*ord->item)->with_sum_func() &&
         (*ord->item)->type() != Item::SUM_FUNC_ITEM)
       (*ord->item)->split_sum_func(thd, ref_pointer_array,
                                    all_fields, SPLIT_SUM_SELECT);
@@ -25018,7 +25019,7 @@ create_distinct_group(THD *thd, Ref_ptr_array ref_pointer_array,
   li.rewind();
   while ((item=li++))
   {
-    if (!item->const_item() && !item->with_sum_func && !item->marker)
+    if (!item->const_item() && !item->with_sum_func() && !item->marker)
     {
       /* 
         Don't put duplicate columns from the SELECT list into the 
@@ -25117,7 +25118,7 @@ count_field_types(SELECT_LEX *select_lex, TMP_TABLE_PARAM *param,
     {
       param->func_count++;
       if (reset_with_sum_func)
-	field->with_sum_func=0;
+	field->flags&= ~ITEM_FLAG_WITH_SUM_FUNC;
     }
   }
 }
@@ -25277,7 +25278,7 @@ void calc_group_buffer(TMP_TABLE_PARAM *param, ORDER *group)
       }
     }
     parts++;
-    if (group_item->maybe_null)
+    if (group_item->maybe_null())
       null_parts++;
   }
   param->group_length= key_length + null_parts;
@@ -25539,7 +25540,7 @@ setup_copy_fields(THD *thd, TMP_TABLE_PARAM *param,
 	      real_pos->real_type() == Item::SUBSELECT_ITEM ||
 	      real_pos->type() == Item::CACHE_ITEM ||
 	      real_pos->type() == Item::COND_ITEM) &&
-	     !real_pos->with_sum_func)
+	     !real_pos->with_sum_func())
     {						// Save for send fields
       LEX_CSTRING real_name= pos->name;
       pos= real_pos;
@@ -25748,8 +25749,8 @@ change_to_use_tmp_fields(THD *thd, Ref_ptr_array ref_pointer_array,
   for (uint i= 0; (item= it++); i++)
   {
     Field *field;
-    if ((item->with_sum_func && item->type() != Item::SUM_FUNC_ITEM) ||
-       item->with_window_func)
+    if ((item->with_sum_func() && item->type() != Item::SUM_FUNC_ITEM) ||
+        item->with_window_func())
       item_field= item;
     else if (item->type() == Item::FIELD_ITEM)
     {
@@ -26012,7 +26013,7 @@ copy_funcs(Item **func_ptr, const THD *thd)
   for (; (func = *func_ptr) ; func_ptr++)
   {
     if (func->type() == Item::FUNC_ITEM &&
-        ((Item_func *) func)->with_window_func)
+        ((Item_func *) func)->with_window_func())
       continue;
     func->save_in_result_field(1);
     /*
@@ -26188,8 +26189,7 @@ static bool change_group_ref(THD *thd, Item_func *expr, ORDER *group_list,
     }
     if (arg_changed)
     {
-      expr->maybe_null= 1;
-      expr->in_rollup= 1;
+      expr->flags|= ITEM_FLAG_MAYBE_NULL | ITEM_FLAG_IN_ROLLUP;
       *changed= TRUE;
     }
   }
@@ -26260,8 +26260,7 @@ bool JOIN::rollup_init()
     {
       if (*group_tmp->item == item)
       {
-        item->maybe_null= 1;
-        item->in_rollup= 1;
+        item->flags|= ITEM_FLAG_MAYBE_NULL | ITEM_FLAG_IN_ROLLUP;
         found_in_group= 1;
         break;
       }
@@ -26277,7 +26276,7 @@ bool JOIN::rollup_init()
         Marking the expression item as 'with_sum_func' will ensure this.
       */ 
       if (changed)
-        item->with_sum_func= 1;
+        item->flags|= ITEM_FLAG_WITH_SUM_FUNC;
     }
   }
   return 0;
@@ -26447,7 +26446,7 @@ bool JOIN::rollup_make_fields(List<Item> &fields_arg, List<Item> &sel_fields,
             Item_null_result *null_item= new (thd->mem_root) Item_null_result(thd);
             if (!null_item)
               return 1;
-	    item->maybe_null= 1;		// Value will be null sometimes
+	    item->flags|= ITEM_FLAG_MAYBE_NULL;		// Value will be null sometimes
             null_item->result_field= item->get_tmp_table_field();
             item= null_item;
 	    break;
@@ -27990,7 +27989,7 @@ void st_select_lex::print(THD *thd, String *str, enum_query_type query_type)
     else
       str->append(',');
 
-    if (is_subquery_function() && item->is_autogenerated_name)
+    if (is_subquery_function() && item->is_autogenerated_name())
     {
       /*
         Do not print auto-generated aliases in subqueries. It has no purpose