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

BUG#19033 (RBR: slave does not handle schema changes correctly):

Browse Source 
Since checking table compatibility before locking the table, there were
potential that a table could be locked that did not have a definition
that was compatible with the table on the slave.

This patch adds a check just after the table was locked to ensure that
the table is (still) compatible with the table on the slave.


sql/log.cc:
  Moving placement new operators to slave.h since they are used in
  several places in the replication code.
  Removing some compile warnings.
sql/log_event.cc:
  Moving code to check table compatibility to after tables are locked for
  writing.
sql/log_event.h:
  Doxygenifying comments.
  Copying error codes to Rows_log_event hierarchy since they are
  now used there as well.
sql/rpl_utility.h:
  Doxygenifying some comments.
  Changing class table_def to copy the column types given to it.
  Adding structure RPL_TABLE_LIST as a subclass of TABLE_LIST to represent
  lists of tables for the slave.
sql/slave.h:
  Adding placement new and delete operators since the slave uses them
  in several places.
sql/sql_insert.cc:
  Removing a compiler warning.
This commit is contained in:
unknown
2007-01-26 19:29:57 +01:00
parent e1b0f07c74
commit 8a8bb772d4
6 changed files with 155 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
sql/rpl_utility.h
View File

@ -24,97 +24,96 @@
#include "mysql_priv.h"
uint32
field_length_from_packed(enum_field_types const field_type,
byte const *const data);
field_length_from_packed(enum_field_types field_type, byte const *data);
/*
/**
A table definition from the master.
RESPONSIBILITIES
The responsibilities of this class is:
- Extract and decode table definition data from the table map event
- Check if table definition in table map is compatible with table
definition on slave
DESCRIPTION
Currently, the only field type data available is an array of the
type operators that are present in the table map event.
Currently, the only field type data available is an array of the
type operators that are present in the table map event.
TODO
Add type operands to this structure to allow detection of
difference between, e.g., BIT(5) and BIT(10).
@todo Add type operands to this structure to allow detection of
difference between, e.g., BIT(5) and BIT(10).
*/
class table_def
{
public:
/*
/**
Convenience declaration of the type of the field type data in a
table map event.
*/
typedef unsigned char field_type;
/*
/**
Constructor.
SYNOPSIS
table_def()
types Array of types
size Number of elements in array 'types'
@param types Array of types
@param size Number of elements in array 'types'
*/
table_def(field_type *types, my_size_t size)
: m_type(types), m_size(size)
: m_type(new unsigned char [size]), m_size(size)
{
if (m_type)
memcpy(m_type, types, size);
else
m_size= 0;
}
/*
~table_def() {
if (m_type)
delete [] m_type;
#ifndef DBUG_OFF
m_type= 0;
m_size= 0;
#endif
}
/**
Return the number of fields there is type data for.
SYNOPSIS
size()
RETURN VALUE
The number of fields that there is type data for.
@return The number of fields that there is type data for.
*/
my_size_t size() const { return m_size; }
/*
Return a representation of the type data for one field.
SYNOPSIS
type()
i Field index to return data for
@param index Field index to return data for
RETURN VALUE
Will return a representation of the type data for field
'i'. Currently, only the type identifier is returned.
@return Will return a representation of the type data for field
<code>index</code>. Currently, only the type identifier is
returned.
*/
field_type type(my_ptrdiff_t i) const { return m_type[i]; }
field_type type(my_ptrdiff_t index) const
{
DBUG_ASSERT(0 <= index);
DBUG_ASSERT(static_cast<my_size_t>(index) < m_size);
return m_type[index];
}
/*
/**
Decide if the table definition is compatible with a table.
SYNOPSIS
compatible_with()
rli Pointer to relay log info
table Pointer to table to compare with.
DESCRIPTION
Compare the definition with a table to see if it is compatible
with it. A table definition is compatible with a table if:
Compare the definition with a table to see if it is compatible
with it.
A table definition is compatible with a table if:
- the columns types of the table definition is a (not
necessarily proper) prefix of the column type of the table, or
- the other way around
RETURN VALUE
1 if the table definition is not compatible with 'table'
0 if the table definition is compatible with 'table'
@param rli Pointer to relay log info
@param table Pointer to table to compare with.
@retval 1 if the table definition is not compatible with @c table
@retval 0 if the table definition is compatible with @c table
*/
int compatible_with(RELAY_LOG_INFO *rli, TABLE *table) const;
@ -123,4 +122,14 @@ private:
field_type *m_type; // Array of type descriptors
};
/**
Extend the normal table list with a few new fields needed by the
slave thread, but nowhere else.
*/
struct RPL_TABLE_LIST
: public st_table_list
{
table_def m_tabledef;
};
#endif /* RPL_UTILITY_H */