database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

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

Browse Source 
(Makes TABLE a bit smaller)
This commit is contained in:
Monty
2015-11-06 13:02:19 +02:00
parent 93d1e5ce0b
commit e3868ee072
7 changed files with 67 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
sql/field.cc
View File

@ -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 " " : "")

3
sql/sql_handler.cc
View File

@ -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);

15
sql/sql_insert.cc
View File

@ -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);

3
sql/sql_lex.cc
View File

@ -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;
}
}

19
sql/sql_select.cc
View File

@ -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;

57
sql/table.cc
View File

@ -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 @@ partititon_err:
/* 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 @@ partititon_err:
}
}
#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
}

9
sql/table.h
View File

@ -1065,12 +1065,15 @@ public:
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 @@ public:
{
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? */