~drizzle-trunk/drizzle/development : contents of sql/rpl

~drizzle-trunk/drizzle/development : (revision 1)

/* Copyright (C) 2006 MySQL AB

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */

#include "rpl_utility.h"
#include "rpl_rli.h"

/*********************************************************************
 *                   table_def member definitions                    *
 *********************************************************************/

/*
  This function returns the field size in raw bytes based on the type
  and the encoded field data from the master's raw data.
*/
uint32 table_def::calc_field_size(uint col, uchar *master_data) const
{
  uint32 length= 0;

  switch (type(col)) {
  case MYSQL_TYPE_NEWDECIMAL:
    length= my_decimal_get_binary_size(m_field_metadata[col] >> 8, 
                                       m_field_metadata[col] & 0xff);
    break;
  case MYSQL_TYPE_DECIMAL:
  case MYSQL_TYPE_FLOAT:
  case MYSQL_TYPE_DOUBLE:
    length= m_field_metadata[col];
    break;
  /*
    The cases for SET and ENUM are include for completeness, however
    both are mapped to type MYSQL_TYPE_STRING and their real types
    are encoded in the field metadata.
  */
  case MYSQL_TYPE_SET:
  case MYSQL_TYPE_ENUM:
  case MYSQL_TYPE_STRING:
  {
    uchar type= m_field_metadata[col] >> 8U;
    if ((type == MYSQL_TYPE_SET) || (type == MYSQL_TYPE_ENUM))
      length= m_field_metadata[col] & 0x00ff;
    else
    {
      /*
        We are reading the actual size from the master_data record
        because this field has the actual lengh stored in the first
        byte.
      */
      length= (uint) *master_data + 1;
      DBUG_ASSERT(length != 0);
    }
    break;
  }
  case MYSQL_TYPE_YEAR:
  case MYSQL_TYPE_TINY:
    length= 1;
    break;
  case MYSQL_TYPE_SHORT:
    length= 2;
    break;
  case MYSQL_TYPE_INT24:
    length= 3;
    break;
  case MYSQL_TYPE_LONG:
    length= 4;
    break;
#ifdef HAVE_LONG_LONG
  case MYSQL_TYPE_LONGLONG:
    length= 8;
    break;
#endif
  case MYSQL_TYPE_NULL:
    length= 0;
    break;
  case MYSQL_TYPE_NEWDATE:
    length= 3;
    break;
  case MYSQL_TYPE_DATE:
  case MYSQL_TYPE_TIME:
    length= 3;
    break;
  case MYSQL_TYPE_TIMESTAMP:
    length= 4;
    break;
  case MYSQL_TYPE_DATETIME:
    length= 8;
    break;
  case MYSQL_TYPE_BIT:
  {
    /*
      Decode the size of the bit field from the master.
        from_len is the length in bytes from the master
        from_bit_len is the number of extra bits stored in the master record
      If from_bit_len is not 0, add 1 to the length to account for accurate
      number of bytes needed.
    */
    uint from_len= (m_field_metadata[col] >> 8U) & 0x00ff;
    uint from_bit_len= m_field_metadata[col] & 0x00ff;
    DBUG_ASSERT(from_bit_len <= 7);
    length= from_len + ((from_bit_len > 0) ? 1 : 0);
    break;
  }
  case MYSQL_TYPE_VARCHAR:
  {
    length= m_field_metadata[col] > 255 ? 2 : 1; // c&p of Field_varstring::data_length()
    DBUG_ASSERT(uint2korr(master_data) > 0);
    length+= length == 1 ? (uint32) *master_data : uint2korr(master_data);
    break;
  }
  case MYSQL_TYPE_TINY_BLOB:
  case MYSQL_TYPE_MEDIUM_BLOB:
  case MYSQL_TYPE_LONG_BLOB:
  case MYSQL_TYPE_BLOB:
  case MYSQL_TYPE_GEOMETRY:
  {
    /*
      Compute the length of the data. We cannot use get_length() here
      since it is dependent on the specific table (and also checks the
      packlength using the internal 'table' pointer) and replication
      is using a fixed format for storing data in the binlog.
    */
    switch (m_field_metadata[col]) {
    case 1:
      length= *master_data;
      break;
    case 2:
      length= uint2korr(master_data);
      break;
    case 3:
      length= uint3korr(master_data);
      break;
    case 4:
      length= uint4korr(master_data);
      break;
    default:
      DBUG_ASSERT(0);		// Should not come here
      break;
    }

    length+= m_field_metadata[col];
    break;
  }
  default:
    length= ~(uint32) 0;
  }
  return length;
}

/*
  Is the definition compatible with a table?

*/
int
table_def::compatible_with(Relay_log_info const *rli_arg, TABLE *table)
  const
{
  /*
    We only check the initial columns for the tables.
  */
  uint const cols_to_check= min(table->s->fields, size());
  int error= 0;
  Relay_log_info const *rli= const_cast<Relay_log_info*>(rli_arg);

  TABLE_SHARE const *const tsh= table->s;

  for (uint col= 0 ; col < cols_to_check ; ++col)
  {
    if (table->field[col]->type() != type(col))
    {
      DBUG_ASSERT(col < size() && col < tsh->fields);
      DBUG_ASSERT(tsh->db.str && tsh->table_name.str);
      error= 1;
      char buf[256];
      my_snprintf(buf, sizeof(buf), "Column %d type mismatch - "
                  "received type %d, %s.%s has type %d",
                  col, type(col), tsh->db.str, tsh->table_name.str,
                  table->field[col]->type());
      rli->report(ERROR_LEVEL, ER_BINLOG_ROW_WRONG_TABLE_DEF,
                  ER(ER_BINLOG_ROW_WRONG_TABLE_DEF), buf);
    }
    /*
      Check the slave's field size against that of the master.
    */
    if (!error && 
        !table->field[col]->compatible_field_size(field_metadata(col)))
    {
      error= 1;
      char buf[256];
      my_snprintf(buf, sizeof(buf), "Column %d size mismatch - "
                  "master has size %d, %s.%s on slave has size %d."
                  " Master's column size should be <= the slave's "
                  "column size.", col,
                  table->field[col]->pack_length_from_metadata(
                                       m_field_metadata[col]),
                  tsh->db.str, tsh->table_name.str, 
                  table->field[col]->row_pack_length());
      rli->report(ERROR_LEVEL, ER_BINLOG_ROW_WRONG_TABLE_DEF,
                  ER(ER_BINLOG_ROW_WRONG_TABLE_DEF), buf);
    }
  }

  return error;
}

1 by brian clean slate	1	/* Copyright (C) 2006 MySQL AB
	2
	3	This program is free software; you can redistribute it and/or modify
	4	it under the terms of the GNU General Public License as published by
	5	the Free Software Foundation; version 2 of the License.
	6
	7	This program is distributed in the hope that it will be useful,
	8	but WITHOUT ANY WARRANTY; without even the implied warranty of
	9	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	10	GNU General Public License for more details.
	11
	12	You should have received a copy of the GNU General Public License
	13	along with this program; if not, write to the Free Software
	14	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
	15
	16	#include "rpl_utility.h"
	17	#include "rpl_rli.h"
	18
	19	/*********************************************************************
	20	* table_def member definitions *
	21	*********************************************************************/
	22
	23	/*
	24	This function returns the field size in raw bytes based on the type
	25	and the encoded field data from the master's raw data.
	26	*/
	27	uint32 table_def::calc_field_size(uint col, uchar *master_data) const
	28	{
	29	uint32 length= 0;
	30
	31	switch (type(col)) {
	32	case MYSQL_TYPE_NEWDECIMAL:
	33	length= my_decimal_get_binary_size(m_field_metadata[col] >> 8,
	34	m_field_metadata[col] & 0xff);
	35	break;
	36	case MYSQL_TYPE_DECIMAL:
	37	case MYSQL_TYPE_FLOAT:
	38	case MYSQL_TYPE_DOUBLE:
	39	length= m_field_metadata[col];
	40	break;
	41	/*
	42	The cases for SET and ENUM are include for completeness, however
	43	both are mapped to type MYSQL_TYPE_STRING and their real types
	44	are encoded in the field metadata.
	45	*/
	46	case MYSQL_TYPE_SET:
	47	case MYSQL_TYPE_ENUM:
	48	case MYSQL_TYPE_STRING:
	49	{
	50	uchar type= m_field_metadata[col] >> 8U;
	51	if ((type == MYSQL_TYPE_SET) \|\| (type == MYSQL_TYPE_ENUM))
	52	length= m_field_metadata[col] & 0x00ff;
	53	else
	54	{
	55	/*
	56	We are reading the actual size from the master_data record
	57	because this field has the actual lengh stored in the first
	58	byte.
	59	*/
	60	length= (uint) *master_data + 1;
	61	DBUG_ASSERT(length != 0);
	62	}
	63	break;
	64	}
65	case MYSQL_TYPE_YEAR:
66	case MYSQL_TYPE_TINY:
67	length= 1;
68	break;
69	case MYSQL_TYPE_SHORT:
70	length= 2;
71	break;
72	case MYSQL_TYPE_INT24:
73	length= 3;
74	break;
75	case MYSQL_TYPE_LONG:
76	length= 4;
77	break;
78	#ifdef HAVE_LONG_LONG
79	case MYSQL_TYPE_LONGLONG:
80	length= 8;
81	break;
82	#endif
83	case MYSQL_TYPE_NULL:
84	length= 0;
85	break;
86	case MYSQL_TYPE_NEWDATE:
87	length= 3;
88	break;
89	case MYSQL_TYPE_DATE:
90	case MYSQL_TYPE_TIME:
91	length= 3;
92	break;
93	case MYSQL_TYPE_TIMESTAMP:
94	length= 4;
95	break;
96	case MYSQL_TYPE_DATETIME:
97	length= 8;
98	break;
99	case MYSQL_TYPE_BIT:
100	{
101	/*
102	Decode the size of the bit field from the master.
103	from_len is the length in bytes from the master
104	from_bit_len is the number of extra bits stored in the master record
105	If from_bit_len is not 0, add 1 to the length to account for accurate
106	number of bytes needed.
107	*/
108	uint from_len= (m_field_metadata[col] >> 8U) & 0x00ff;
109	uint from_bit_len= m_field_metadata[col] & 0x00ff;
110	DBUG_ASSERT(from_bit_len <= 7);
111	length= from_len + ((from_bit_len > 0) ? 1 : 0);
112	break;
113	}
114	case MYSQL_TYPE_VARCHAR:
115	{
116	length= m_field_metadata[col] > 255 ? 2 : 1; // c&p of Field_varstring::data_length()
117	DBUG_ASSERT(uint2korr(master_data) > 0);
118	length+= length == 1 ? (uint32) *master_data : uint2korr(master_data);
119	break;
120	}
121	case MYSQL_TYPE_TINY_BLOB:
122	case MYSQL_TYPE_MEDIUM_BLOB:
123	case MYSQL_TYPE_LONG_BLOB:
124	case MYSQL_TYPE_BLOB:
125	case MYSQL_TYPE_GEOMETRY:
126	{
127	/*
128	Compute the length of the data. We cannot use get_length() here
129	since it is dependent on the specific table (and also checks the
130	packlength using the internal 'table' pointer) and replication
131	is using a fixed format for storing data in the binlog.
132	*/
133	switch (m_field_metadata[col]) {
134	case 1:
135	length= *master_data;
136	break;
137	case 2:
138	length= uint2korr(master_data);
139	break;
140	case 3:
141	length= uint3korr(master_data);
142	break;
143	case 4:
144	length= uint4korr(master_data);
145	break;
146	default:
147	DBUG_ASSERT(0); // Should not come here
148	break;
149	}
150
151	length+= m_field_metadata[col];
152	break;
153	}
154	default:
155	length= ~(uint32) 0;
156	}
157	return length;
158	}
159
160	/*
161	Is the definition compatible with a table?
162
163	*/
164	int
165	table_def::compatible_with(Relay_log_info const rli_arg, TABLE table)
166	const
167	{
168	/*
169	We only check the initial columns for the tables.
170	*/
171	uint const cols_to_check= min(table->s->fields, size());
172	int error= 0;
173	Relay_log_info const rli= const_cast<Relay_log_info>(rli_arg);
174
175	TABLE_SHARE const *const tsh= table->s;
176
177	for (uint col= 0 ; col < cols_to_check ; ++col)
178	{
179	if (table->field[col]->type() != type(col))
180	{
181	DBUG_ASSERT(col < size() && col < tsh->fields);
182	DBUG_ASSERT(tsh->db.str && tsh->table_name.str);
183	error= 1;
184	char buf[256];
185	my_snprintf(buf, sizeof(buf), "Column %d type mismatch - "
186	"received type %d, %s.%s has type %d",
187	col, type(col), tsh->db.str, tsh->table_name.str,
188	table->field[col]->type());
189	rli->report(ERROR_LEVEL, ER_BINLOG_ROW_WRONG_TABLE_DEF,
190	ER(ER_BINLOG_ROW_WRONG_TABLE_DEF), buf);
191	}
192	/*
193	Check the slave's field size against that of the master.
194	*/
195	if (!error &&
196	!table->field[col]->compatible_field_size(field_metadata(col)))
197	{
198	error= 1;
199	char buf[256];
200	my_snprintf(buf, sizeof(buf), "Column %d size mismatch - "
201	"master has size %d, %s.%s on slave has size %d."
202	" Master's column size should be <= the slave's "
203	"column size.", col,
204	table->field[col]->pack_length_from_metadata(
205	m_field_metadata[col]),
206	tsh->db.str, tsh->table_name.str,
207	table->field[col]->row_pack_length());
208	rli->report(ERROR_LEVEL, ER_BINLOG_ROW_WRONG_TABLE_DEF,
209	ER(ER_BINLOG_ROW_WRONG_TABLE_DEF), buf);
210	}
211	}
212
213	return error;
214	}