Don't store vcol bitmaps in TABLE if table doesn't have virtual fields.

(Makes TABLE a bit smaller)
MariaDB · Nov 10, 2015 · e3868ee · e3868ee
1 parent 93d1e5c
commit e3868ee
Show file tree

Hide file tree

Showing 7 changed files with 67 additions and 41 deletions.
diff --git a/sql/field.cc b/sql/field.cc
@@ -71,7 +71,7 @@ const char field_separator=',';
                         ((ulong) ((1LL << MY_MIN(arg, 4) * 8) - 1))
 
 #define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
-#define ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED DBUG_ASSERT(is_stat_field || !table || (!table->write_set || bitmap_is_set(table->write_set, field_index) || bitmap_is_set(table->vcol_set, field_index)))
+#define ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED DBUG_ASSERT(is_stat_field || !table || (!table->write_set || bitmap_is_set(table->write_set, field_index) || (table->vcol_set && bitmap_is_set(table->vcol_set, field_index))))
 
 #define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
 

diff --git a/sql/sql_handler.cc b/sql/sql_handler.cc
@@ -375,7 +375,8 @@ bool mysql_ha_open(THD *thd, TABLE_LIST *tables, SQL_HANDLER *reopen)
 
   /* Always read all columns */
   table->read_set= &table->s->all_set;
-  table->vcol_set= &table->s->all_set;
+  if (table->vcol_set)
+    table->vcol_set= &table->s->all_set;
 
   /* Restore the state. */
   thd->set_open_tables(backup_open_tables);

diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
@@ -2470,6 +2470,9 @@ TABLE *Delayed_insert::get_local_table(THD* client_thd)
 
   if (share->vfields)
   {
+    if (!(copy->def_vcol_set= (MY_BITMAP*) alloc_root(client_thd->mem_root,
+                                                      sizeof(MY_BITMAP))))
+      goto error;
     copy->vfield= vfield;
     for (field= copy->field; *field; field++)
     {
@@ -2502,13 +2505,17 @@ TABLE *Delayed_insert::get_local_table(THD* client_thd)
   copy->def_read_set.bitmap= (my_bitmap_map*) bitmap;
   copy->def_write_set.bitmap= ((my_bitmap_map*)
                                (bitmap + share->column_bitmap_size));
-  copy->def_vcol_set.bitmap= ((my_bitmap_map*)
-                               (bitmap + 2*share->column_bitmap_size));
+  if (share->vfields)
+  {
+    my_bitmap_init(copy->def_vcol_set,
+                   (my_bitmap_map*) (bitmap + 2*share->column_bitmap_size),
+                   share->fields, FALSE);
+    copy->vcol_set= copy->def_vcol_set;
+  }
   copy->tmp_set.bitmap= 0;                      // To catch errors
-  bzero((char*) bitmap, share->column_bitmap_size*3);
+  bzero((char*) bitmap, share->column_bitmap_size + (share->vfields ? 3 : 2));
   copy->read_set=  &copy->def_read_set;
   copy->write_set= &copy->def_write_set;
-  copy->vcol_set= &copy->def_vcol_set;
 
   DBUG_RETURN(copy);
 

diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
@@ -3867,7 +3867,8 @@ void SELECT_LEX::update_used_tables()
           tab->covering_keys.intersect(tab->keys_in_use_for_query);
           tab->merge_keys.clear_all();
           bitmap_clear_all(tab->read_set);
-          bitmap_clear_all(tab->vcol_set);
+          if (tab->vcol_set)
+            bitmap_clear_all(tab->vcol_set);
           break;
         }
       }

diff --git a/sql/sql_select.cc b/sql/sql_select.cc
@@ -16141,20 +16141,21 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
 void setup_tmp_table_column_bitmaps(TABLE *table, uchar *bitmaps)
 {
   uint field_count= table->s->fields;
+  uint bitmap_size= bitmap_buffer_size(field_count);
+
+  DBUG_ASSERT(table->s->vfields == 0 && table->def_vcol_set == 0);
+
   my_bitmap_init(&table->def_read_set, (my_bitmap_map*) bitmaps, field_count,
               FALSE);
-  my_bitmap_init(&table->def_vcol_set,
-              (my_bitmap_map*) (bitmaps+ bitmap_buffer_size(field_count)),
-              field_count, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&table->tmp_set,
-              (my_bitmap_map*) (bitmaps+ 2*bitmap_buffer_size(field_count)),
-              field_count, FALSE);
+                 (my_bitmap_map*) bitmaps, field_count, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&table->eq_join_set,
-              (my_bitmap_map*) (bitmaps+ 3*bitmap_buffer_size(field_count)),
-              field_count, FALSE);
+                 (my_bitmap_map*) bitmaps, field_count, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&table->cond_set,
-              (my_bitmap_map*) (bitmaps+ 4*bitmap_buffer_size(field_count)),
-              field_count, FALSE);
+                 (my_bitmap_map*) bitmaps, field_count, FALSE);
   /* write_set and all_set are copies of read_set */
   table->def_write_set= table->def_read_set;
   table->s->all_set= table->def_read_set;

diff --git a/sql/table.cc b/sql/table.cc
@@ -2585,7 +2585,7 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
                        bool is_create_table)
 {
   enum open_frm_error error;
-  uint records, i, bitmap_size;
+  uint records, i, bitmap_size, bitmap_count;
   bool error_reported= FALSE;
   uchar *record, *bitmaps;
   Field **field_ptr, **UNINIT_VAR(vfield_ptr), **UNINIT_VAR(dfield_ptr);
@@ -2885,28 +2885,42 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
   /* Allocate bitmaps */
 
   bitmap_size= share->column_bitmap_size;
-  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root, bitmap_size*7)))
+  bitmap_count= 6;
+  if (share->vfields)
+  {
+    if (!(outparam->def_vcol_set= (MY_BITMAP*)
+          alloc_root(&outparam->mem_root, sizeof(*outparam->def_vcol_set))))
+      goto err;
+    bitmap_count++;
+  }
+  if (!(bitmaps= (uchar*) alloc_root(&outparam->mem_root,
+                                     bitmap_size * bitmap_count)))
     goto err;
+
   my_bitmap_init(&outparam->def_read_set,
                  (my_bitmap_map*) bitmaps, share->fields, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&outparam->def_write_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size), share->fields,
-                 FALSE);
-  my_bitmap_init(&outparam->def_vcol_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size*2), share->fields,
-                 FALSE);
+                 (my_bitmap_map*) bitmaps, share->fields, FALSE);
+  bitmaps+= bitmap_size;
+  if (share->vfields)
+  {
+    /* Don't allocate vcol_bitmap if we don't need it */
+    my_bitmap_init(outparam->def_vcol_set,
+                   (my_bitmap_map*) bitmaps, share->fields, FALSE);
+    bitmaps+= bitmap_size;
+  }
   my_bitmap_init(&outparam->tmp_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size*3), share->fields,
-                 FALSE);
+                 (my_bitmap_map*) bitmaps, share->fields, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&outparam->eq_join_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size*4), share->fields,
-                 FALSE);
+                 (my_bitmap_map*) bitmaps, share->fields, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&outparam->cond_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size*5), share->fields,
-                 FALSE);
+                 (my_bitmap_map*) bitmaps, share->fields, FALSE);
+  bitmaps+= bitmap_size;
   my_bitmap_init(&outparam->def_rpl_write_set,
-                 (my_bitmap_map*) (bitmaps+bitmap_size*6), share->fields,
-                 FALSE);
+                 (my_bitmap_map*) bitmaps, share->fields, FALSE);
   outparam->default_column_bitmaps();
 
   outparam->cond_selectivity= 1.0;
@@ -2955,10 +2969,6 @@ enum open_frm_error open_table_from_share(THD *thd, TABLE_SHARE *share,
     }
   }
 
-#if defined(HAVE_valgrind) && !defined(DBUG_OFF)
-  bzero((char*) bitmaps, bitmap_size*3);
-#endif
-
   if (share->table_category == TABLE_CATEGORY_LOG)
   {
     outparam->no_replicate= TRUE;
@@ -5683,10 +5693,13 @@ void TABLE::clear_column_bitmaps()
     Reset column read/write usage. It's identical to:
     bitmap_clear_all(&table->def_read_set);
     bitmap_clear_all(&table->def_write_set);
-    bitmap_clear_all(&table->def_vcol_set);
+    if (s->vfields) bitmap_clear_all(table->def_vcol_set);
+    The code assumes that the bitmaps are allocated after each other, as
+    guaranteed by open_table_from_share()
   */
-  bzero((char*) def_read_set.bitmap, s->column_bitmap_size*3);
-  column_bitmaps_set(&def_read_set, &def_write_set, &def_vcol_set);
+  bzero((char*) def_read_set.bitmap,
+        s->column_bitmap_size * (s->vfields ? 3 : 2));
+  column_bitmaps_set(&def_read_set, &def_write_set, def_vcol_set);
   rpl_write_set= 0;                             // Safety
 }
 

diff --git a/sql/table.h b/sql/table.h
@@ -1065,12 +1065,15 @@ struct TABLE
   ORDER		*group;
   String	alias;            	  /* alias or table name */
   uchar		*null_flags;
-  MY_BITMAP     def_read_set, def_write_set, def_vcol_set, tmp_set;
+  MY_BITMAP     def_read_set, def_write_set, tmp_set;
   MY_BITMAP     def_rpl_write_set;
   MY_BITMAP     eq_join_set;         /* used to mark equi-joined fields */
   MY_BITMAP     cond_set;   /* used to mark fields from sargable conditions*/
   /* Active column sets */
-  MY_BITMAP     *read_set, *write_set, *vcol_set, *rpl_write_set;
+  MY_BITMAP     *read_set, *write_set, *rpl_write_set;
+  /* Set if using virtual fields */
+  MY_BITMAP     *vcol_set, *def_vcol_set;
+
   /*
    The ID of the query that opened and is using this table. Has different
    meanings depending on the table type.
@@ -1322,7 +1325,7 @@ struct TABLE
   {
     read_set= &def_read_set;
     write_set= &def_write_set;
-    vcol_set= &def_vcol_set;
+    vcol_set= def_vcol_set;                     /* Note that this may be 0 */
     rpl_write_set= 0;
   }
   /** Should this instance of the table be reopened? */