Merge lp:~tsarev/percona-server/5.1-18205-wl5151 into lp:percona-server/5.1

[Oleg Tsarev]

https://blueprints.launchpad.net/percona-server/+spec/wl5151

Need work of documentation engineer.

Unmerged revisions

431. By Oleg Tsarev on 2012-02-22

add documentation for wl5151

430. By Oleg Tsarev on 2012-02-21

Merge feature WL #5151

429. By Oleg Tsarev on 2012-02-16

Merge feature WL #47 - annotate rows log events

428. By Oleg Tsarev on 2012-02-16

merge lp:~tsarev/percona-server/5.1-18205_02_wl36.patch

=== modified file 'Percona-Server/client/mysqlbinlog.cc'
--- Percona-Server/client/mysqlbinlog.cc	2012-02-22 07:32:22 +0000
+++ Percona-Server/client/mysqlbinlog.cc	2012-02-22 07:32:24 +0000
@@ -44,6 +44,7 @@
 #include "sql_string.h"                          // needed for Rpl_filter
 #include "sql_list.h"                            // needed for Rpl_filter
 #include "rpl_filter.h"
+#include "rpl_utility.cc"
 
 Rpl_filter *binlog_filter;
 

=== modified file 'Percona-Server/libmysqld/Makefile.am'
--- Percona-Server/libmysqld/Makefile.am	2011-06-30 15:37:13 +0000
+++ Percona-Server/libmysqld/Makefile.am	2012-02-22 07:32:24 +0000
@@ -57,7 +57,7 @@
 	item_xmlfunc.cc \
 	key.cc lock.cc log.cc sql_state.c \
 	log_event.cc rpl_record.cc \
-	log_event_old.cc rpl_record_old.cc \
+	log_event_old.cc rpl_record_old.cc rpl_utility.cc \
 	protocol.cc net_serv.cc opt_range.cc \
 	opt_sum.cc procedure.cc records.cc sql_acl.cc \
 	sql_load.cc discover.cc sql_locale.cc \

=== added file 'Percona-Server/mysql-test/extra/rpl_tests/check_type.inc'
--- Percona-Server/mysql-test/extra/rpl_tests/check_type.inc	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/check_type.inc	2012-02-22 07:32:24 +0000
@@ -0,0 +1,52 @@
+# Helper file to perform one insert of a value into a table with
+# different types on master and slave.  The file will insert the
+# result into the type_conversions table *on the slave* to get a
+# summary of failing and succeeding tests.
+
+# Input:
+#    $source_type      Type on the master
+#    $target_type      Type on the slave
+#    $source_value     Value on the master (inserted into the table)
+#    $target_value     Value on the slave (expected value in the table
+#                      on the slave)
+#    $can_convert      True if conversion shall work, false if it
+#                      shall generate an error 
+
+
+connection master;
+disable_warnings;
+DROP TABLE IF EXISTS t1;
+enable_warnings;
+eval CREATE TABLE t1 (a $source_type);
+sync_slave_with_master;
+eval ALTER TABLE t1 MODIFY a $target_type;
+
+connection master;
+eval INSERT INTO t1 VALUES($source_value);
+if ($can_convert) {
+  sync_slave_with_master;
+  eval SELECT a = $target_value into @compare FROM t1;
+  eval INSERT INTO type_conversions SET
+       Source = "$source_type",
+       Target = "$target_type",
+       Flags = @@slave_type_conversions,
+       On_Master = $source_value,
+       Expected = $target_value,
+       Compare = @compare;
+  UPDATE type_conversions
+     SET On_Slave = (SELECT a FROM t1)
+   WHERE TestNo = LAST_INSERT_ID();
+}
+if (!$can_convert) {
+  connection slave;
+  wait_for_slave_to_stop;
+  let $error = query_get_value("SHOW SLAVE STATUS", Last_SQL_Error, 1);
+  eval INSERT INTO type_conversions SET
+       Source = "$source_type",
+       Target = "$target_type",
+       Flags = @@slave_type_conversions,
+       On_Master = $source_value,
+       Error = "$error";
+  SET GLOBAL SQL_SLAVE_SKIP_COUNTER = 1;
+  START SLAVE;
+}

=== modified file 'Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_master.test'
--- Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_master.test	2011-03-31 13:48:05 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_master.test	2012-02-22 07:32:24 +0000
@@ -124,6 +124,7 @@
 
 --disable_query_log
 call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 2 type mismatch.* 1535");
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
 call mtr.add_suppression("Slave.*Can.t DROP .c7.; check that column.key exists.* Error_code: 1091");
 call mtr.add_suppression("Slave.*Unknown column .c7. in .t15.* Error_code: 1054");
 call mtr.add_suppression("Slave.*Key column .c6. doesn.t exist in table.* Error_code: 1072");
@@ -479,12 +480,12 @@
 
 --echo
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 --echo
 connection slave;
-# 1535 = ER_BINLOG_ROW_WRONG_TABLE_DEF
---let $slave_sql_errno= 1535
+# 1677 = ER_BINLOG_ROW_WRONG_TABLE_DEF
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -535,12 +536,12 @@
 
 --echo
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 --echo
 connection slave;
-# 1535 = ER_BINLOG_ROW_WRONG_TABLE_DEF
---let $slave_sql_errno= 1535
+# 1677 = ER_BINLOG_ROW_WRONG_TABLE_DEF
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc

=== modified file 'Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_slave.test'
--- Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_slave.test	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/rpl_extra_col_slave.test	2012-02-22 07:32:24 +0000
@@ -13,6 +13,9 @@
 #          should stop the slave.               #
 #################################################
 
+--disable_query_log
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+--enable_query_log
 call mtr.add_suppression("Slave: Unknown table 't6' Error_code: 1051");
 
 --echo **** Diff Table Def Start ****
@@ -27,6 +30,9 @@
 STOP SLAVE;
 RESET SLAVE;
 
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
+
 eval CREATE TABLE t1 (a INT, b INT PRIMARY KEY, c CHAR(20),
                       d FLOAT DEFAULT '2.00', 
                       e CHAR(4) DEFAULT 'TEST') 
@@ -53,6 +59,8 @@
 sync_slave_with_master;
 SELECT * FROM t1 ORDER BY a;
 
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
+
 --echo *** Drop t1  ***
 connection master;
 DROP TABLE t1;
@@ -87,7 +95,7 @@
 --echo *** Start Slave ***
 connection slave;
 START SLAVE;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error.inc
 STOP SLAVE;
@@ -136,10 +144,10 @@
 INSERT INTO t3 () VALUES(@b1,2,'Kyle, TEX'),(@b1,1,'JOE AUSTIN'),(@b1,4,'QA TESTING');
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -179,10 +187,10 @@
                         (30000.22,4,'QA TESTING');
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -222,10 +230,10 @@
                         (2,'JOE',300.01,0,'b2b2',1.0000009);
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -266,10 +274,10 @@
                         (2,'JOE',300.01,0);
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error.inc
 SET GLOBAL SQL_SLAVE_SKIP_COUNTER=3;
@@ -470,10 +478,10 @@
 INSERT INTO t10 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -492,7 +500,7 @@
 --echo  *** Create t11 on slave  ***
 STOP SLAVE;
 RESET SLAVE;
-eval CREATE TABLE t11 (a INT KEY, b BLOB, f TEXT,
+eval CREATE TABLE t11 (a INT KEY, b BLOB, f INT,
                       c CHAR(5) DEFAULT 'test', e INT DEFAULT '1')ENGINE=$engine_type;
 
 --echo *** Create t11 on Master ***
@@ -512,10 +520,10 @@
 INSERT INTO t11 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
@@ -899,10 +907,10 @@
 INSERT INTO t17 () VALUES(9223372036854775807,2,'Kyle, TEX');
 
 --echo ********************************************
---echo *** Expect slave to fail with Error 1535 ***
+--echo *** Expect slave to fail with Error 1677 ***
 --echo ********************************************
 connection slave;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $slave_skip_counter= 2
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc

=== modified file 'Percona-Server/mysql-test/extra/rpl_tests/rpl_row_basic.test'
--- Percona-Server/mysql-test/extra/rpl_tests/rpl_row_basic.test	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/rpl_row_basic.test	2012-02-22 07:32:24 +0000
@@ -6,6 +6,10 @@
 # First we test tables with only an index.
 #
 
+--disable_query_log
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+--enable_query_log
+connection master;
 eval CREATE TABLE t1 (C1 CHAR(1), C2 CHAR(1), INDEX (C1)$extra_index_t1) ENGINE = $type ;
 SELECT * FROM t1;
 sync_slave_with_master;
@@ -156,6 +160,12 @@
 # Testing special column types
 #
 
+if (`select char_length('$bit_field_special') > 0`) {
+  SET @saved_slave_type_conversions = @@SLAVE_TYPE_CONVERSIONS;
+  connection slave;
+  eval SET GLOBAL SLAVE_TYPE_CONVERSIONS = '$bit_field_special';
+}
+
 connection master;
 eval CREATE TABLE t4 (C1 CHAR(1) PRIMARY KEY, B1 BIT(1), B2 BIT(1) NOT NULL DEFAULT 0, C2 CHAR(1) NOT NULL DEFAULT 'A') ENGINE = $type ;
 
@@ -164,6 +174,10 @@
 sync_slave_with_master;
 SELECT C1,HEX(B1),HEX(B2) FROM t4 ORDER BY C1;
 
+if (`select char_length('$bit_field_special') > 0`) {
+  SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
+}
+
 #
 # Testing conflicting operations
 #
@@ -347,6 +361,10 @@
                       c CHAR(255) CHARACTER SET utf8 NOT NULL,
                       j INT NOT NULL) ENGINE = $type ;
 
+connection slave;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
+
 --echo [expecting slave to replicate correctly]
 connection master;
 INSERT INTO t1 VALUES (1, "", 1);
@@ -365,18 +383,9 @@
 let $diff_tables= master:t2, slave:t2;
 source include/diff_tables.inc;
 
---echo [expecting slave to stop]
-connection master;
-INSERT INTO t3 VALUES (1, "", 1);
-INSERT INTO t3 VALUES (2, repeat(_utf8'a', 128), 2);
 
 connection slave;
-# 1535 = ER_BINLOG_ROW_WRONG_TABLE_DEF
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 1 size mismatch.* Error_code: 1535");
 call mtr.add_suppression("Slave SQL.*Could not execute Delete_rows event on table test.t1.* Error_code: 1032");
---let $slave_sql_errno= 1535
---let $show_slave_sql_error= 1
---source include/wait_for_slave_sql_error.inc
 
 --let $rpl_only_running_threads= 1
 --source include/rpl_reset.inc
@@ -396,8 +405,8 @@
 INSERT INTO t5 VALUES (2, repeat(_utf8'a', 255), 2);
 
 connection slave;
-# 1535 = ER_BINLOG_ROW_WRONG_TABLE_DEF 
---let $slave_sql_errno= 1535
+# 1677 = ER_BINLOG_ROW_WRONG_TABLE_DEF 
+--let $slave_sql_errno= 1677 
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error.inc
 
@@ -409,8 +418,8 @@
 INSERT INTO t6 VALUES (2, repeat(_utf8'a', 255), 2);
 
 connection slave;
-# 1535 = ER_BINLOG_ROW_WRONG_TABLE_DEF 
---let $slave_sql_errno= 1535
+# 1677 = ER_BINLOG_ROW_WRONG_TABLE_DEF 
+--let $slave_sql_errno= 1677 
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error.inc
 
@@ -575,7 +584,15 @@
 
 connection master;
 
+# Since t1 contain a bit field, we have to do this trick to handle InnoDB
+if (`select char_length('$bit_field_special') > 0`) {
+  SET @saved_slave_type_conversions = @@SLAVE_TYPE_CONVERSIONS;
+  connection slave;
+  eval SET GLOBAL SLAVE_TYPE_CONVERSIONS = '$bit_field_special';
+}
+
 --disable_warnings
+connection master;
 eval CREATE TABLE t1 (a bit) ENGINE=$type;
 INSERT IGNORE INTO t1 VALUES (NULL);
 INSERT INTO t1 ( a ) VALUES ( 0 );
@@ -620,9 +637,20 @@
 
 sync_slave_with_master;
 
+if (`select char_length('$bit_field_special') > 0`) {
+  SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
+}
+
 let $diff_tables= master:t1, slave:t1;
 source include/diff_tables.inc;
 
 connection master;
 drop table t1;
 sync_slave_with_master;
+
+--disable_query_log
+--disable_result_log
+connection slave;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS=default;
+--enable_result_log
+--enable_query_log

=== modified file 'Percona-Server/mysql-test/extra/rpl_tests/rpl_row_tabledefs.test'
--- Percona-Server/mysql-test/extra/rpl_tests/rpl_row_tabledefs.test	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/rpl_row_tabledefs.test	2012-02-22 07:32:24 +0000
@@ -147,9 +147,9 @@
 connection master;
 INSERT INTO t4 VALUES (4);
 connection slave;
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column [012] type mismatch.* Error_code: 1535");
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
 --let $slave_skip_counter= 2
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
 
@@ -161,7 +161,7 @@
 INSERT INTO t5 VALUES (5,10,25);
 connection slave;
 --let $slave_skip_counter= 2
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
 
@@ -173,7 +173,7 @@
 INSERT INTO t6 VALUES (6,12,36);
 connection slave;
 --let $slave_skip_counter= 2
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error_and_skip.inc
 

=== added file 'Percona-Server/mysql-test/extra/rpl_tests/type_conversions.test'
--- Percona-Server/mysql-test/extra/rpl_tests/type_conversions.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/extra/rpl_tests/type_conversions.test	2012-02-22 07:32:24 +0000
@@ -0,0 +1,882 @@
+# File containing different lossy and non-lossy type conversions.
+
+# Integral conversion testing, we do not reduce the test using
+# transitivity of conversions since the implementation is not using a
+# transitivity strategy. Instead we do an exhaustive testing.
+
+disable_query_log;
+connection slave;
+--let $conv = `select @@slave_type_conversions`
+--echo **** Running tests with @@SLAVE_TYPE_CONVERSIONS = '$conv' ****
+
+let $if_is_lossy = `SELECT FIND_IN_SET('ALL_LOSSY', @@SLAVE_TYPE_CONVERSIONS)`;
+let $if_is_non_lossy = `SELECT FIND_IN_SET('ALL_NON_LOSSY', @@SLAVE_TYPE_CONVERSIONS)`;
+
+# TINYBLOB
+
+let $source_type  = TINYBLOB;
+let $target_type  = TINYBLOB;
+let $source_value = 'aaa';
+let $target_value = 'aaa';
+let $can_convert   = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYBLOB;
+let $target_type= BLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYBLOB;
+let $target_type= MEDIUMBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYBLOB;
+let $target_type= LONGBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+# BLOB
+
+let $source_type  = BLOB;
+let $target_type  = TINYBLOB;
+let $source_value = 'aaa';
+let $target_value = 'aaa';
+let $can_convert   = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BLOB;
+let $target_type= BLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BLOB;
+let $target_type= MEDIUMBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BLOB;
+let $target_type= LONGBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+# MEDIUMBLOB
+
+let $source_type  = MEDIUMBLOB;
+let $target_type  = TINYBLOB;
+let $source_value = 'aaa';
+let $target_value = 'aaa';
+let $can_convert   = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMBLOB;
+let $target_type= BLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMBLOB;
+let $target_type= MEDIUMBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMBLOB;
+let $target_type= LONGBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+# LONGBLOB
+
+let $source_type  = LONGBLOB;
+let $target_type  = TINYBLOB;
+let $source_value = 'aaa';
+let $target_value = 'aaa';
+let $can_convert   = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= LONGBLOB;
+let $target_type= BLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= LONGBLOB;
+let $target_type= MEDIUMBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= LONGBLOB;
+let $target_type= LONGBLOB;
+let $source_value= 'aaa';
+let $target_value= 'aaa';
+let $can_convert= 1;
+source extra/rpl_tests/check_type.inc;
+
+# BUG#49836 (additional tests - GEOMETRY TYPE)
+
+let $source_type  = GEOMETRY;
+let $target_type  = BLOB;
+let $source_value = PointFromText('POINT(10 10)');
+let $target_value = PointFromText('POINT(10 10)');
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = BLOB;
+let $target_type  = GEOMETRY;
+let $source_value = 'aaa';
+let $target_value = 'aaa';
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = GEOMETRY;
+let $target_type  = GEOMETRY;
+let $source_value = PointFromText('POINT(10 10)');
+let $target_value = PointFromText('POINT(10 10)');
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = BIT(1);
+let $target_type  = BIT(1);
+let $source_value = b'1';
+let $target_value = b'1';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = DATE;
+let $target_type  = DATE;
+let $source_value = '2009-11-21';
+let $target_value = '2009-11-21';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = ENUM('master','slave');
+let $target_type  = ENUM('master','slave');
+let $source_value = 'master';
+let $target_value = 'master';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = CHAR(10);
+let $target_type  = ENUM('master','slave');
+let $source_value = 'master';
+let $target_value = 'master';
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = CHAR(10);
+let $target_type  = SET('master','slave');
+let $source_value = 'master';
+let $target_value = 'master';
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = ENUM('master','slave');
+let $target_type  = CHAR(10);
+let $source_value = 'master';
+let $target_value = 'master';
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('master','slave');
+let $target_type  = CHAR(10);
+let $source_value = 'master';
+let $target_value = 'master';
+let $can_convert  = 0;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('master','slave');
+let $target_type  = SET('master','slave');
+let $source_value = '';
+let $target_value = '';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('master','slave');
+let $target_type  = SET('master','slave');
+let $source_value = 'master,slave';
+let $target_value = 'master,slave';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('0','1','2','3','4','5','6');
+let $target_type  = SET('0','1','2','3','4','5','6');
+let $source_value = '5';
+let $target_value = '5';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('0','1','2','3','4','5','6');
+let $target_type  = SET('0','1','2','3','4','5','6','7','8','9','10');
+let $source_value = '5';
+let $target_value = '5';
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('0','1','2','3','4','5','6','7','8','9','10');
+let $target_type  = SET('0','1','2','3','4','5','6');
+let $source_value = '5';
+let $target_value = '5';
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = SET('0','1','2','3','4','5','6','7','8','9','10');
+let $target_type  = SET('0','1','2','3','4','5','6');
+let $source_value = '7';
+let $target_value = '';
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = TINYINT;
+let $target_type  = TINYINT;
+let $source_value = 1;
+let $target_value = 1;
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type  = TINYINT;
+let $target_type  = SMALLINT;
+let $source_value = 1;
+let $target_value = 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYINT;
+let $target_type= MEDIUMINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYINT;
+let $target_type= INT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYINT;
+let $target_type= BIGINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= TINYINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= TINYINT;
+let $source_value= 1 << 9;
+let $target_value= (1 << 7) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= TINYINT UNSIGNED;
+let $source_value= 1 << 9;
+let $target_value= (1 << 8) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= SMALLINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= MEDIUMINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= INT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= SMALLINT;
+let $target_type= BIGINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= TINYINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= TINYINT;
+let $source_value= 1 << 20;
+let $target_value= (1 << 7) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= TINYINT UNSIGNED;
+let $source_value= 1 << 20;
+let $target_value= (1 << 8) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= SMALLINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= MEDIUMINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= INT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMINT;
+let $target_type= BIGINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= TINYINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= TINYINT;
+let $source_value= (1 << 30);
+let $target_value= (1 << 7) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= TINYINT UNSIGNED;
+let $source_value= (1 << 30);
+let $target_value= (1 << 8) - 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= SMALLINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= MEDIUMINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= INT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= INT;
+let $target_type= BIGINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIGINT;
+let $target_type= TINYINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIGINT;
+let $target_type= SMALLINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIGINT;
+let $target_type= MEDIUMINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIGINT;
+let $target_type= INT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIGINT;
+let $target_type= BIGINT;
+let $source_value= 1;
+let $target_value= 1;
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= CHAR(20);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert  = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= CHAR(30);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= CHAR(10);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnood';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= VARCHAR(20);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= VARCHAR(30);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= VARCHAR(10);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnood';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= TINYTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= TEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= MEDIUMTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= CHAR(20);
+let $target_type= LONGTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= VARCHAR(20);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= VARCHAR(30);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= VARCHAR(10);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnood';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= CHAR(30);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= CHAR(10);
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnood';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= TINYTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= TEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= MEDIUMTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(20);
+let $target_type= LONGTEXT;
+let $source_value= 'Smoothnoodlemaps';
+let $target_value= 'Smoothnoodlemaps';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $blob = `select repeat('abcd', 125)`;
+let $truncated_blob = `select left('$blob', 255)`;
+
+let $source_type= VARCHAR(500);
+let $target_type= VARCHAR(500);
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= VARCHAR(510);
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= VARCHAR(255);
+let $source_value= '$blob';
+let $target_value= '$truncated_blob';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= TINYTEXT;
+let $source_value= '$blob';
+let $target_value= '$truncated_blob';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= TEXT;
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= MEDIUMTEXT;
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= VARCHAR(500);
+let $target_type= LONGTEXT;
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $tiny_blob = `select repeat('tiny blob ', 25)`;
+let $truncated_tiny_blob = `select left('$tiny_blob', 254)`;
+
+let $source_type= TINYTEXT;
+let $target_type= VARCHAR(500);
+let $source_value= '$tiny_blob';
+let $target_value= '$tiny_blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TEXT;
+let $target_type= VARCHAR(500);
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMTEXT;
+let $target_type= VARCHAR(500);
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= LONGTEXT;
+let $target_type= VARCHAR(500);
+let $source_value= '$blob';
+let $target_value= '$blob';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYTEXT;
+let $target_type= CHAR(255);
+let $source_value= '$tiny_blob';
+let $target_value= '$tiny_blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYTEXT;
+let $target_type= CHAR(250);
+let $source_value= '$tiny_blob';
+let $target_value= left('$tiny_blob', 250);
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TEXT;
+let $target_type= CHAR(255);
+let $source_value= '$blob';
+let $target_value= left('$blob', 255);
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= MEDIUMTEXT;
+let $target_type= CHAR(255);
+let $source_value= '$blob';
+let $target_value= left('$blob', 255);
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= LONGTEXT;
+let $target_type= CHAR(255);
+let $source_value= '$blob';
+let $target_value= left('$blob', 255);
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYTEXT;
+let $target_type= TINYTEXT;
+let $source_value= '$tiny_blob';
+let $target_value= '$tiny_blob';
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TINYTEXT;
+let $target_type= TEXT;
+let $source_value= '$tiny_blob';
+let $target_value= '$tiny_blob';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= TEXT;
+let $target_type= TINYTEXT;
+let $source_value= '$blob';
+let $target_value= left('$blob',255);
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(10,5);
+let $source_value= 3.14159;
+let $target_value= 3.14159;
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(10,6);
+let $source_value= 3.14159;
+let $target_value= 3.141590;
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(11,5);
+let $source_value= 3.14159;
+let $target_value= 3.14159;
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(11,6);
+let $source_value= 3.14159;
+let $target_value= 3.141590;
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(10,4);
+let $source_value= 3.14159;
+let $target_value= 3.1416;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(9,5);
+let $source_value= 3.14159;
+let $target_value= 3.14159;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DECIMAL(9,4);
+let $source_value= 3.14159;
+let $target_value= 3.1416;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= FLOAT;
+let $target_type= DECIMAL(10,5);
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DOUBLE;
+let $target_type= DECIMAL(10,5);
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= FLOAT;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DECIMAL(10,5);
+let $target_type= DOUBLE;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= FLOAT;
+let $target_type= FLOAT;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DOUBLE;
+let $target_type= DOUBLE;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= FLOAT;
+let $target_type= DOUBLE;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= DOUBLE;
+let $target_type= FLOAT;
+let $source_value= 3.15625;
+let $target_value= 3.15625;
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIT(5);
+let $target_type= BIT(5);
+let $source_value= b'11001';
+let $target_value= b'11001';
+let $can_convert = 1;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIT(5);
+let $target_type= BIT(6);
+let $source_value= b'11001';
+let $target_value= b'11001';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIT(6);
+let $target_type= BIT(5);
+let $source_value= b'111001';
+let $target_value= b'11111';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIT(5);
+let $target_type= BIT(12);
+let $source_value= b'11001';
+let $target_value= b'11001';
+let $can_convert = $if_is_non_lossy;
+source extra/rpl_tests/check_type.inc;
+
+let $source_type= BIT(12);
+let $target_type= BIT(5);
+let $source_value= b'101100111000';
+let $target_value= b'11111';
+let $can_convert = $if_is_lossy;
+source extra/rpl_tests/check_type.inc;
+
+
+disable_warnings;
+source include/rpl_reset.inc;
+enable_warnings;
+enable_query_log;

=== modified file 'Percona-Server/mysql-test/include/test_fieldsize.inc'
--- Percona-Server/mysql-test/include/test_fieldsize.inc	2010-05-24 13:54:08 +0000
+++ Percona-Server/mysql-test/include/test_fieldsize.inc	2012-02-22 07:32:24 +0000
@@ -22,7 +22,7 @@
 
 connection slave;
 START SLAVE;
---let $slave_sql_errno= 1535
+--let $slave_sql_errno= 1677
 --let $show_slave_sql_error= 1
 --source include/wait_for_slave_sql_error.inc
 

=== modified file 'Percona-Server/mysql-test/r/percona_server_variables_debug.result'
--- Percona-Server/mysql-test/r/percona_server_variables_debug.result	2012-02-22 07:32:22 +0000
+++ Percona-Server/mysql-test/r/percona_server_variables_debug.result	2012-02-22 07:32:24 +0000
@@ -293,6 +293,7 @@
 SLAVE_NET_TIMEOUT
 SLAVE_SKIP_ERRORS
 SLAVE_TRANSACTION_RETRIES
+SLAVE_TYPE_CONVERSIONS
 SLOW_LAUNCH_TIME
 SLOW_QUERY_LOG
 SLOW_QUERY_LOG_FILE

=== modified file 'Percona-Server/mysql-test/r/percona_server_variables_release.result'
--- Percona-Server/mysql-test/r/percona_server_variables_release.result	2012-02-22 07:32:22 +0000
+++ Percona-Server/mysql-test/r/percona_server_variables_release.result	2012-02-22 07:32:24 +0000
@@ -290,6 +290,7 @@
 SLAVE_NET_TIMEOUT
 SLAVE_SKIP_ERRORS
 SLAVE_TRANSACTION_RETRIES
+SLAVE_TYPE_CONVERSIONS
 SLOW_LAUNCH_TIME
 SLOW_QUERY_LOG
 SLOW_QUERY_LOG_FILE

=== modified file 'Percona-Server/mysql-test/suite/binlog/r/binlog_base64_flag.result'
--- Percona-Server/mysql-test/suite/binlog/r/binlog_base64_flag.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/binlog/r/binlog_base64_flag.result	2012-02-22 07:32:24 +0000
@@ -93,6 +93,7 @@
 drop table t1, char63_utf8, char128_utf8;
 call mtr.add_suppression("Slave SQL.*master suffers from this bug: http:..bugs.mysql.com.bug.php.id=37426.* Error_code: 1105");
 call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 1 size mismatch.* Error_code: 1535");
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
 #
 # Bug #54393: crash and/or valgrind errors in 
 # mysql_client_binlog_statement

=== modified file 'Percona-Server/mysql-test/suite/binlog/t/binlog_base64_flag.test'
--- Percona-Server/mysql-test/suite/binlog/t/binlog_base64_flag.test	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/binlog/t/binlog_base64_flag.test	2012-02-22 07:32:24 +0000
@@ -153,6 +153,7 @@
 
 call mtr.add_suppression("Slave SQL.*master suffers from this bug: http:..bugs.mysql.com.bug.php.id=37426.* Error_code: 1105");
 call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 1 size mismatch.* Error_code: 1535");
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
 
 --echo #
 --echo # Bug #54393: crash and/or valgrind errors in 

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_bug31076.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_bug31076.result	2010-12-19 17:07:28 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_bug31076.result	2012-02-22 07:32:24 +0000
@@ -1,5 +1,7 @@
 include/master-slave.inc
 [connection master]
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 CREATE DATABASE track;
 USE track;
 CREATE TABLE `visits` (
@@ -61,6 +63,7 @@
 SELECT * FROM visits_events;
 event_id	visit_id	timestamp	src	data	visits_events_id
 20000	21231038	2007-09-18 03:59:02		Downloads/MySQL-4.1/mysql-4.1.12a-win32.zip	33712207
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 DROP DATABASE track;
 End of 5.1 tests
 include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_colSize.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_colSize.result	2010-12-19 17:07:28 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_colSize.result	2012-02-22 07:32:24 +0000
@@ -5,6 +5,8 @@
 *** Create "wider" table on slave ***
 STOP SLAVE;
 RESET SLAVE;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 CREATE TABLE t1 (
 a float     (47),
 b double    (143,9),
@@ -173,4 +175,5 @@
 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
 *** Cleanup  ***
 DROP TABLE t1;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_innodb.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_innodb.result	2011-03-31 08:33:07 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_innodb.result	2012-02-22 07:32:24 +0000
@@ -457,11 +457,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -493,11 +493,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;
@@ -1328,11 +1328,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -1364,11 +1364,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;
@@ -2199,11 +2199,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -2235,11 +2235,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_myisam.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_myisam.result	2011-03-31 08:33:07 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_master_myisam.result	2012-02-22 07:32:24 +0000
@@ -457,11 +457,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -493,11 +493,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;
@@ -1328,11 +1328,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -1364,11 +1364,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;
@@ -2199,11 +2199,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 5, test.t10 has type 254'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'double' to type 'char(5)''
 
 *** Drop t10  ***
 DROP TABLE t10;
@@ -2235,11 +2235,11 @@
 (3,@b1,DEFAULT,'QA',DEFAULT);
 
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
 
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 252, test.t11 has type 15'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'tinyblob' to type 'varchar(254)''
 
 *** Drop t11  ***
 DROP TABLE t11;

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_innodb.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_innodb.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_innodb.result	2012-02-22 07:32:24 +0000
@@ -5,6 +5,8 @@
 *** On Slave ***
 STOP SLAVE;
 RESET SLAVE;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 CREATE TABLE t1 (a INT, b INT PRIMARY KEY, c CHAR(20),
 d FLOAT DEFAULT '2.00', 
 e CHAR(4) DEFAULT 'TEST') 
@@ -28,6 +30,7 @@
 1	2	TEXAS	2	TEST
 2	1	AUSTIN	2	TEST
 3	4	QA	2	TEST
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 *** Drop t1  ***
 DROP TABLE t1;
 *** Create t2 on slave  ***
@@ -50,8 +53,8 @@
 3	4	QA TESTING
 *** Start Slave ***
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 size mismatch - master has size 10, test.t2 on slave has size 6. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t2' cannot be converted from type 'char(10)' to type 'char(5)''
 STOP SLAVE;
 RESET SLAVE;
 SELECT * FROM t2 ORDER BY a;
@@ -78,10 +81,10 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t3 () VALUES(@b1,2,'Kyle, TEX'),(@b1,1,'JOE AUSTIN'),(@b1,4,'QA TESTING');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 252, test.t3 has type 3'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t3' cannot be converted from type 'tinyblob' to type 'int(11)''
 *** Drop t3  ***
 DROP TABLE t3;
 *** Create t4 on slave  ***
@@ -101,10 +104,10 @@
 INSERT INTO t4 () VALUES(100.22,2,'Kyle, TEX'),(200.26,1,'JOE AUSTIN'),
 (30000.22,4,'QA TESTING');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 246, test.t4 has type 3'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t4' cannot be converted from type 'decimal(8,2)' to type 'int(11)''
 *** Drop t4  ***
 DROP TABLE t4;
 *** Create t5 on slave  ***
@@ -124,10 +127,10 @@
 INSERT INTO t5 () VALUES(1,'Kyle',200.23,1,'b1b1',23.00098),
 (2,'JOE',300.01,0,'b2b2',1.0000009);
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 5 type mismatch - received type 4, test.t5 has type 246'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'varchar(6)' to type 'char(5)''
 *** Drop t5  ***
 DROP TABLE t5;
 *** Create t6 on slave  ***
@@ -146,10 +149,10 @@
 INSERT INTO t6 () VALUES(1,'Kyle',200.23,1),
 (2,'JOE',300.01,0);
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 3 type mismatch - received type 16, test.t6 has type 3'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t6' cannot be converted from type 'varchar(6)' to type 'char(5)''
 SET GLOBAL SQL_SLAVE_SKIP_COUNTER=3;
 *** Drop t6  ***
 DROP TABLE t6;
@@ -246,16 +249,16 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t10 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 254, test.t10 has type 5'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'char(5)' to type 'double''
 *** Drop t10  ***
 DROP TABLE t10;
 *** Create t11 on slave  ***
 STOP SLAVE;
 RESET SLAVE;
-CREATE TABLE t11 (a INT KEY, b BLOB, f TEXT,
+CREATE TABLE t11 (a INT KEY, b BLOB, f INT,
 c CHAR(5) DEFAULT 'test', e INT DEFAULT '1')ENGINE='InnoDB';
 *** Create t11 on Master ***
 CREATE TABLE t11 (a INT PRIMARY KEY, b BLOB, c VARCHAR(254)
@@ -268,10 +271,10 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t11 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 15, test.t11 has type 252'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'varchar(254)' to type 'int(11)''
 *** Drop t11  ***
 DROP TABLE t11;
 *** Create t12 on slave  ***
@@ -584,10 +587,10 @@
 *** Master Data Insert ***
 INSERT INTO t17 () VALUES(9223372036854775807,2,'Kyle, TEX');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 8, test.t17 has type 2'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t17' cannot be converted from type 'bigint' to type 'smallint(6)''
 ** DROP table t17 ***
 DROP TABLE t17;
 include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_myisam.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_myisam.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_extra_col_slave_myisam.result	2012-02-22 07:32:24 +0000
@@ -5,6 +5,8 @@
 *** On Slave ***
 STOP SLAVE;
 RESET SLAVE;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 CREATE TABLE t1 (a INT, b INT PRIMARY KEY, c CHAR(20),
 d FLOAT DEFAULT '2.00', 
 e CHAR(4) DEFAULT 'TEST') 
@@ -28,6 +30,7 @@
 1	2	TEXAS	2	TEST
 2	1	AUSTIN	2	TEST
 3	4	QA	2	TEST
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 *** Drop t1  ***
 DROP TABLE t1;
 *** Create t2 on slave  ***
@@ -50,8 +53,8 @@
 3	4	QA TESTING
 *** Start Slave ***
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 size mismatch - master has size 10, test.t2 on slave has size 6. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t2' cannot be converted from type 'char(10)' to type 'char(5)''
 STOP SLAVE;
 RESET SLAVE;
 SELECT * FROM t2 ORDER BY a;
@@ -78,10 +81,10 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t3 () VALUES(@b1,2,'Kyle, TEX'),(@b1,1,'JOE AUSTIN'),(@b1,4,'QA TESTING');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 252, test.t3 has type 3'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t3' cannot be converted from type 'tinyblob' to type 'int(11)''
 *** Drop t3  ***
 DROP TABLE t3;
 *** Create t4 on slave  ***
@@ -101,10 +104,10 @@
 INSERT INTO t4 () VALUES(100.22,2,'Kyle, TEX'),(200.26,1,'JOE AUSTIN'),
 (30000.22,4,'QA TESTING');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 246, test.t4 has type 3'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t4' cannot be converted from type 'decimal(8,2)' to type 'int(11)''
 *** Drop t4  ***
 DROP TABLE t4;
 *** Create t5 on slave  ***
@@ -124,10 +127,10 @@
 INSERT INTO t5 () VALUES(1,'Kyle',200.23,1,'b1b1',23.00098),
 (2,'JOE',300.01,0,'b2b2',1.0000009);
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 5 type mismatch - received type 4, test.t5 has type 246'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'varchar(6)' to type 'char(5)''
 *** Drop t5  ***
 DROP TABLE t5;
 *** Create t6 on slave  ***
@@ -146,10 +149,10 @@
 INSERT INTO t6 () VALUES(1,'Kyle',200.23,1),
 (2,'JOE',300.01,0);
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 3 type mismatch - received type 16, test.t6 has type 3'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t6' cannot be converted from type 'varchar(6)' to type 'char(5)''
 SET GLOBAL SQL_SLAVE_SKIP_COUNTER=3;
 *** Drop t6  ***
 DROP TABLE t6;
@@ -246,16 +249,16 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t10 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 254, test.t10 has type 5'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t10' cannot be converted from type 'char(5)' to type 'double''
 *** Drop t10  ***
 DROP TABLE t10;
 *** Create t11 on slave  ***
 STOP SLAVE;
 RESET SLAVE;
-CREATE TABLE t11 (a INT KEY, b BLOB, f TEXT,
+CREATE TABLE t11 (a INT KEY, b BLOB, f INT,
 c CHAR(5) DEFAULT 'test', e INT DEFAULT '1')ENGINE='MyISAM';
 *** Create t11 on Master ***
 CREATE TABLE t11 (a INT PRIMARY KEY, b BLOB, c VARCHAR(254)
@@ -268,10 +271,10 @@
 set @b1 = concat(@b1,@b1);
 INSERT INTO t11 () VALUES(1,@b1,'Kyle'),(2,@b1,'JOE'),(3,@b1,'QA');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 15, test.t11 has type 252'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t11' cannot be converted from type 'varchar(254)' to type 'int(11)''
 *** Drop t11  ***
 DROP TABLE t11;
 *** Create t12 on slave  ***
@@ -584,10 +587,10 @@
 *** Master Data Insert ***
 INSERT INTO t17 () VALUES(9223372036854775807,2,'Kyle, TEX');
 ********************************************
-*** Expect slave to fail with Error 1535 ***
+*** Expect slave to fail with Error 1677 ***
 ********************************************
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 8, test.t17 has type 2'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t17' cannot be converted from type 'bigint' to type 'smallint(6)''
 ** DROP table t17 ***
 DROP TABLE t17;
 include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_2myisam.result	2012-02-22 07:32:24 +0000
@@ -467,6 +467,8 @@
 CREATE TABLE t7 (i INT NOT NULL,
 c CHAR(255) CHARACTER SET utf8 NOT NULL,
 j INT NOT NULL) ENGINE = 'MYISAM'  ;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 [expecting slave to replicate correctly]
 INSERT INTO t1 VALUES (1, "", 1);
 INSERT INTO t1 VALUES (2, repeat(_utf8'a', 16), 2);
@@ -475,13 +477,7 @@
 INSERT INTO t2 VALUES (1, "", 1);
 INSERT INTO t2 VALUES (2, repeat(_utf8'a', 16), 2);
 include/diff_tables.inc [master:t2, slave:t2]
-[expecting slave to stop]
-INSERT INTO t3 VALUES (1, "", 1);
-INSERT INTO t3 VALUES (2, repeat(_utf8'a', 128), 2);
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 1 size mismatch.* Error_code: 1535");
 call mtr.add_suppression("Slave SQL.*Could not execute Delete_rows event on table test.t1.* Error_code: 1032");
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 384, test.t3 on slave has size 49. Master's column size should be <= the slave's column size.'
 include/rpl_reset.inc
 [expecting slave to replicate correctly]
 INSERT INTO t4 VALUES (1, "", 1);
@@ -490,14 +486,14 @@
 [expecting slave to stop]
 INSERT INTO t5 VALUES (1, "", 1);
 INSERT INTO t5 VALUES (2, repeat(_utf8'a', 255), 2);
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 765, test.t5 on slave has size 49. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677 ]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'char(255)' to type 'char(16)''
 include/rpl_reset.inc
 [expecting slave to stop]
 INSERT INTO t6 VALUES (1, "", 1);
 INSERT INTO t6 VALUES (2, repeat(_utf8'a', 255), 2);
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 765, test.t6 on slave has size 385. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677 ]
+Last_SQL_Error = 'Column 1 of table 'test.t6' cannot be converted from type 'char(255)' to type 'char(128)''
 include/rpl_reset.inc
 [expecting slave to replicate correctly]
 INSERT INTO t7 VALUES (1, "", 1);

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_row_basic_3innodb.result	2012-02-22 07:32:24 +0000
@@ -350,6 +350,8 @@
 X	Q	5	7	R	49	X	Z	2	S	2
 X	Q	5	9	R	81	X	Y	2	S	1
 X	Q	5	9	R	81	X	Z	2	S	2
+SET @saved_slave_type_conversions = @@SLAVE_TYPE_CONVERSIONS;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_LOSSY';
 CREATE TABLE t4 (C1 CHAR(1) PRIMARY KEY, B1 BIT(1), B2 BIT(1) NOT NULL DEFAULT 0, C2 CHAR(1) NOT NULL DEFAULT 'A') ENGINE = 'INNODB'  ;
 INSERT INTO t4 SET C1 = 1;
 SELECT C1,HEX(B1),HEX(B2) FROM t4 ORDER BY C1;
@@ -358,6 +360,7 @@
 SELECT C1,HEX(B1),HEX(B2) FROM t4 ORDER BY C1;
 C1	HEX(B1)	HEX(B2)
 1	NULL	0
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 CREATE TABLE t7 (C1 INT PRIMARY KEY, C2 INT) ENGINE = 'INNODB'  ;
 --- on slave: original values ---
 INSERT INTO t7 VALUES (1,3), (2,6), (3,9);
@@ -467,6 +470,8 @@
 CREATE TABLE t7 (i INT NOT NULL,
 c CHAR(255) CHARACTER SET utf8 NOT NULL,
 j INT NOT NULL) ENGINE = 'INNODB'  ;
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
 [expecting slave to replicate correctly]
 INSERT INTO t1 VALUES (1, "", 1);
 INSERT INTO t1 VALUES (2, repeat(_utf8'a', 16), 2);
@@ -475,13 +480,7 @@
 INSERT INTO t2 VALUES (1, "", 1);
 INSERT INTO t2 VALUES (2, repeat(_utf8'a', 16), 2);
 include/diff_tables.inc [master:t2, slave:t2]
-[expecting slave to stop]
-INSERT INTO t3 VALUES (1, "", 1);
-INSERT INTO t3 VALUES (2, repeat(_utf8'a', 128), 2);
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column 1 size mismatch.* Error_code: 1535");
 call mtr.add_suppression("Slave SQL.*Could not execute Delete_rows event on table test.t1.* Error_code: 1032");
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 384, test.t3 on slave has size 49. Master's column size should be <= the slave's column size.'
 include/rpl_reset.inc
 [expecting slave to replicate correctly]
 INSERT INTO t4 VALUES (1, "", 1);
@@ -490,14 +489,14 @@
 [expecting slave to stop]
 INSERT INTO t5 VALUES (1, "", 1);
 INSERT INTO t5 VALUES (2, repeat(_utf8'a', 255), 2);
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 765, test.t5 on slave has size 49. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677 ]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'char(255)' to type 'char(16)''
 include/rpl_reset.inc
 [expecting slave to stop]
 INSERT INTO t6 VALUES (1, "", 1);
 INSERT INTO t6 VALUES (2, repeat(_utf8'a', 255), 2);
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 size mismatch - master has size 765, test.t6 on slave has size 385. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677 ]
+Last_SQL_Error = 'Column 1 of table 'test.t6' cannot be converted from type 'char(255)' to type 'char(128)''
 include/rpl_reset.inc
 [expecting slave to replicate correctly]
 INSERT INTO t7 VALUES (1, "", 1);
@@ -581,6 +580,8 @@
 UPDATE t1 SET a = 8 WHERE a < 5;
 include/diff_tables.inc [master:t1, slave:t1]
 drop table t1;
+SET @saved_slave_type_conversions = @@SLAVE_TYPE_CONVERSIONS;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_LOSSY';
 CREATE TABLE t1 (a bit) ENGINE='INNODB' ;
 INSERT IGNORE INTO t1 VALUES (NULL);
 INSERT INTO t1 ( a ) VALUES ( 0 );
@@ -621,6 +622,7 @@
 UPDATE t1 SET a = 8 WHERE a = 5 LIMIT 2;
 INSERT INTO t1 ( a ) VALUES ( 1 );
 UPDATE t1 SET a = 9 WHERE a < 5 LIMIT 3;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
 include/diff_tables.inc [master:t1, slave:t1]
 drop table t1;
 include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_row_colSize.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_row_colSize.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_row_colSize.result	2012-02-22 07:32:24 +0000
@@ -14,8 +14,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (901251.90125);
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 10, test.t1 on slave has size 3. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'decimal(20,10)' to type 'decimal(5,2)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -31,8 +31,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (901251.90125);
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 12, test.t1 on slave has size 12. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'decimal(27,18)' to type 'decimal(27,9)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -48,8 +48,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (901251.90125);
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 10, test.t1 on slave has size 3. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'decimal(20,10)' to type 'decimal(5,2)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -66,8 +66,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (901251.90125);
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 5, test.t1 has type 4'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'double' to type 'float''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -84,8 +84,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (B'10101');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 8, test.t1 on slave has size 1. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'bit(64)' to type 'bit(5)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -101,8 +101,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES (B'10101');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 2, test.t1 on slave has size 2. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'bit(12)' to type 'bit(11)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -119,8 +119,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('4');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 2, test.t1 on slave has size 1. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'set' to type 'set('4')''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -137,8 +137,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('This is a test.');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 20, test.t1 on slave has size 11. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'char(20)' to type 'char(10)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -186,8 +186,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('44');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 2, test.t1 on slave has size 1. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'enum' to type 'enum('44','54')''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -204,8 +204,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('This is a test.');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 2000, test.t1 on slave has size 100. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'varchar(2000)' to type 'varchar(100)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -221,8 +221,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('This is a test.');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 200, test.t1 on slave has size 10. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'varchar(200)' to type 'varchar(10)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -238,8 +238,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('This is a test.');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 2000, test.t1 on slave has size 1000. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'varchar(2000)' to type 'varchar(1000)''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0
@@ -256,8 +256,8 @@
 RESET MASTER;
 INSERT INTO t1 VALUES ('This is a test.');
 START SLAVE;
-include/wait_for_slave_sql_error.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 size mismatch - master has size 4, test.t1 on slave has size 1. Master's column size should be <= the slave's column size.'
+include/wait_for_slave_sql_error.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t1' cannot be converted from type 'tinyblob' to type 'tinyblob''
 SELECT COUNT(*) FROM t1;
 COUNT(*)
 0

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_2myisam.result	2012-02-22 07:32:24 +0000
@@ -117,17 +117,17 @@
 include/check_slave_is_running.inc
 INSERT INTO t9 VALUES (4);
 INSERT INTO t4 VALUES (4);
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column [012] type mismatch.* Error_code: 1535");
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 3, test.t4 has type 4'
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t4' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (5);
 INSERT INTO t5 VALUES (5,10,25);
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 type mismatch - received type 3, test.t5 has type 4'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (6);
 INSERT INTO t6 VALUES (6,12,36);
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 3, test.t6 has type 4'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t6' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (6);
 include/check_slave_is_running.inc
 INSERT INTO t7 VALUES (1),(2),(3);

=== modified file 'Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_row_tabledefs_3innodb.result	2012-02-22 07:32:24 +0000
@@ -117,17 +117,17 @@
 include/check_slave_is_running.inc
 INSERT INTO t9 VALUES (4);
 INSERT INTO t4 VALUES (4);
-call mtr.add_suppression("Slave SQL.*Table definition on master and slave does not match: Column [012] type mismatch.* Error_code: 1535");
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 0 type mismatch - received type 3, test.t4 has type 4'
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 0 of table 'test.t4' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (5);
 INSERT INTO t5 VALUES (5,10,25);
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 1 type mismatch - received type 3, test.t5 has type 4'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 1 of table 'test.t5' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (6);
 INSERT INTO t6 VALUES (6,12,36);
-include/wait_for_slave_sql_error_and_skip.inc [errno=1535]
-Last_SQL_Error = 'Table definition on master and slave does not match: Column 2 type mismatch - received type 3, test.t6 has type 4'
+include/wait_for_slave_sql_error_and_skip.inc [errno=1677]
+Last_SQL_Error = 'Column 2 of table 'test.t6' cannot be converted from type 'int' to type 'float''
 INSERT INTO t9 VALUES (6);
 include/check_slave_is_running.inc
 INSERT INTO t7 VALUES (1),(2),(3);

=== added file 'Percona-Server/mysql-test/suite/rpl/r/rpl_typeconv.result'
--- Percona-Server/mysql-test/suite/rpl/r/rpl_typeconv.result	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/rpl/r/rpl_typeconv.result	2012-02-22 07:32:24 +0000
@@ -0,0 +1,539 @@
+include/master-slave.inc
+[connection master]
+set @saved_slave_type_conversions = @@global.slave_type_conversions;
+CREATE TABLE type_conversions (
+TestNo INT AUTO_INCREMENT PRIMARY KEY,
+Source TEXT,
+Target TEXT,
+Flags TEXT,
+On_Master TEXT,
+On_Slave TEXT,
+Expected TEXT,
+Compare INT,
+Error TEXT);
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+ALL_NON_LOSSY
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY';
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+ALL_LOSSY
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY';
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+ALL_LOSSY,ALL_NON_LOSSY
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY,NONEXISTING_BIT';
+ERROR 42000: Variable 'slave_type_conversions' can't be set to the value of 'NONEXISTING_BIT'
+SELECT @@global.slave_type_conversions;
+@@global.slave_type_conversions
+ALL_LOSSY,ALL_NON_LOSSY
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+**** Running tests with @@SLAVE_TYPE_CONVERSIONS = '' ****
+include/rpl_reset.inc
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+**** Running tests with @@SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY' ****
+include/rpl_reset.inc
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY';
+**** Running tests with @@SLAVE_TYPE_CONVERSIONS = 'ALL_LOSSY' ****
+include/rpl_reset.inc
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY';
+**** Running tests with @@SLAVE_TYPE_CONVERSIONS = 'ALL_LOSSY,ALL_NON_LOSSY' ****
+include/rpl_reset.inc
+**** Result of conversions ****
+Source_Type	Target_Type	All_Type_Conversion_Flags	Value_On_Slave
+TINYBLOB       	TINYBLOB       	                         	<Correct value>
+TINYBLOB       	BLOB           	                         	<Correct error>
+TINYBLOB       	MEDIUMBLOB     	                         	<Correct error>
+TINYBLOB       	LONGBLOB       	                         	<Correct error>
+BLOB           	TINYBLOB       	                         	<Correct error>
+BLOB           	BLOB           	                         	<Correct value>
+BLOB           	MEDIUMBLOB     	                         	<Correct error>
+BLOB           	LONGBLOB       	                         	<Correct error>
+MEDIUMBLOB     	TINYBLOB       	                         	<Correct error>
+MEDIUMBLOB     	BLOB           	                         	<Correct error>
+MEDIUMBLOB     	MEDIUMBLOB     	                         	<Correct value>
+MEDIUMBLOB     	LONGBLOB       	                         	<Correct error>
+LONGBLOB       	TINYBLOB       	                         	<Correct error>
+LONGBLOB       	BLOB           	                         	<Correct error>
+LONGBLOB       	MEDIUMBLOB     	                         	<Correct error>
+LONGBLOB       	LONGBLOB       	                         	<Correct value>
+GEOMETRY       	BLOB           	                         	<Correct error>
+BLOB           	GEOMETRY       	                         	<Correct error>
+GEOMETRY       	GEOMETRY       	                         	<Correct value>
+BIT(1)         	BIT(1)         	                         	<Correct value>
+DATE           	DATE           	                         	<Correct value>
+ENUM('master','	ENUM('master','	                         	<Correct value>
+CHAR(10)       	ENUM('master','	                         	<Correct error>
+CHAR(10)       	SET('master','s	                         	<Correct error>
+ENUM('master','	CHAR(10)       	                         	<Correct error>
+SET('master','s	CHAR(10)       	                         	<Correct error>
+SET('master','s	SET('master','s	                         	<Correct value>
+SET('master','s	SET('master','s	                         	<Correct value>
+SET('0','1','2'	SET('0','1','2'	                         	<Correct value>
+SET('0','1','2'	SET('0','1','2'	                         	<Correct error>
+SET('0','1','2'	SET('0','1','2'	                         	<Correct error>
+SET('0','1','2'	SET('0','1','2'	                         	<Correct error>
+TINYINT        	TINYINT        	                         	<Correct value>
+TINYINT        	SMALLINT       	                         	<Correct error>
+TINYINT        	MEDIUMINT      	                         	<Correct error>
+TINYINT        	INT            	                         	<Correct error>
+TINYINT        	BIGINT         	                         	<Correct error>
+SMALLINT       	TINYINT        	                         	<Correct error>
+SMALLINT       	TINYINT        	                         	<Correct error>
+SMALLINT       	TINYINT UNSIGNE	                         	<Correct error>
+SMALLINT       	SMALLINT       	                         	<Correct value>
+SMALLINT       	MEDIUMINT      	                         	<Correct error>
+SMALLINT       	INT            	                         	<Correct error>
+SMALLINT       	BIGINT         	                         	<Correct error>
+MEDIUMINT      	TINYINT        	                         	<Correct error>
+MEDIUMINT      	TINYINT        	                         	<Correct error>
+MEDIUMINT      	TINYINT UNSIGNE	                         	<Correct error>
+MEDIUMINT      	SMALLINT       	                         	<Correct error>
+MEDIUMINT      	MEDIUMINT      	                         	<Correct value>
+MEDIUMINT      	INT            	                         	<Correct error>
+MEDIUMINT      	BIGINT         	                         	<Correct error>
+INT            	TINYINT        	                         	<Correct error>
+INT            	TINYINT        	                         	<Correct error>
+INT            	TINYINT UNSIGNE	                         	<Correct error>
+INT            	SMALLINT       	                         	<Correct error>
+INT            	MEDIUMINT      	                         	<Correct error>
+INT            	INT            	                         	<Correct value>
+INT            	BIGINT         	                         	<Correct error>
+BIGINT         	TINYINT        	                         	<Correct error>
+BIGINT         	SMALLINT       	                         	<Correct error>
+BIGINT         	MEDIUMINT      	                         	<Correct error>
+BIGINT         	INT            	                         	<Correct error>
+BIGINT         	BIGINT         	                         	<Correct value>
+CHAR(20)       	CHAR(20)       	                         	<Correct value>
+CHAR(20)       	CHAR(30)       	                         	<Correct error>
+CHAR(20)       	CHAR(10)       	                         	<Correct error>
+CHAR(20)       	VARCHAR(20)    	                         	<Correct error>
+CHAR(20)       	VARCHAR(30)    	                         	<Correct error>
+CHAR(20)       	VARCHAR(10)    	                         	<Correct error>
+CHAR(20)       	TINYTEXT       	                         	<Correct error>
+CHAR(20)       	TEXT           	                         	<Correct error>
+CHAR(20)       	MEDIUMTEXT     	                         	<Correct error>
+CHAR(20)       	LONGTEXT       	                         	<Correct error>
+VARCHAR(20)    	VARCHAR(20)    	                         	<Correct value>
+VARCHAR(20)    	VARCHAR(30)    	                         	<Correct error>
+VARCHAR(20)    	VARCHAR(10)    	                         	<Correct error>
+VARCHAR(20)    	CHAR(30)       	                         	<Correct error>
+VARCHAR(20)    	CHAR(10)       	                         	<Correct error>
+VARCHAR(20)    	TINYTEXT       	                         	<Correct error>
+VARCHAR(20)    	TEXT           	                         	<Correct error>
+VARCHAR(20)    	MEDIUMTEXT     	                         	<Correct error>
+VARCHAR(20)    	LONGTEXT       	                         	<Correct error>
+VARCHAR(500)   	VARCHAR(500)   	                         	<Correct value>
+VARCHAR(500)   	VARCHAR(510)   	                         	<Correct error>
+VARCHAR(500)   	VARCHAR(255)   	                         	<Correct error>
+VARCHAR(500)   	TINYTEXT       	                         	<Correct error>
+VARCHAR(500)   	TEXT           	                         	<Correct error>
+VARCHAR(500)   	MEDIUMTEXT     	                         	<Correct error>
+VARCHAR(500)   	LONGTEXT       	                         	<Correct error>
+TINYTEXT       	VARCHAR(500)   	                         	<Correct error>
+TEXT           	VARCHAR(500)   	                         	<Correct error>
+MEDIUMTEXT     	VARCHAR(500)   	                         	<Correct error>
+LONGTEXT       	VARCHAR(500)   	                         	<Correct error>
+TINYTEXT       	CHAR(255)      	                         	<Correct error>
+TINYTEXT       	CHAR(250)      	                         	<Correct error>
+TEXT           	CHAR(255)      	                         	<Correct error>
+MEDIUMTEXT     	CHAR(255)      	                         	<Correct error>
+LONGTEXT       	CHAR(255)      	                         	<Correct error>
+TINYTEXT       	TINYTEXT       	                         	<Correct value>
+TINYTEXT       	TEXT           	                         	<Correct error>
+TEXT           	TINYTEXT       	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(10,5)  	                         	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,6)  	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(11,5)  	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(11,6)  	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(10,4)  	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(9,5)   	                         	<Correct error>
+DECIMAL(10,5)  	DECIMAL(9,4)   	                         	<Correct error>
+FLOAT          	DECIMAL(10,5)  	                         	<Correct error>
+DOUBLE         	DECIMAL(10,5)  	                         	<Correct error>
+DECIMAL(10,5)  	FLOAT          	                         	<Correct error>
+DECIMAL(10,5)  	DOUBLE         	                         	<Correct error>
+FLOAT          	FLOAT          	                         	<Correct value>
+DOUBLE         	DOUBLE         	                         	<Correct value>
+FLOAT          	DOUBLE         	                         	<Correct error>
+DOUBLE         	FLOAT          	                         	<Correct error>
+BIT(5)         	BIT(5)         	                         	<Correct value>
+BIT(5)         	BIT(6)         	                         	<Correct error>
+BIT(6)         	BIT(5)         	                         	<Correct error>
+BIT(5)         	BIT(12)        	                         	<Correct error>
+BIT(12)        	BIT(5)         	                         	<Correct error>
+TINYBLOB       	TINYBLOB       	ALL_NON_LOSSY            	<Correct value>
+TINYBLOB       	BLOB           	ALL_NON_LOSSY            	<Correct value>
+TINYBLOB       	MEDIUMBLOB     	ALL_NON_LOSSY            	<Correct value>
+TINYBLOB       	LONGBLOB       	ALL_NON_LOSSY            	<Correct value>
+BLOB           	TINYBLOB       	ALL_NON_LOSSY            	<Correct error>
+BLOB           	BLOB           	ALL_NON_LOSSY            	<Correct value>
+BLOB           	MEDIUMBLOB     	ALL_NON_LOSSY            	<Correct value>
+BLOB           	LONGBLOB       	ALL_NON_LOSSY            	<Correct value>
+MEDIUMBLOB     	TINYBLOB       	ALL_NON_LOSSY            	<Correct error>
+MEDIUMBLOB     	BLOB           	ALL_NON_LOSSY            	<Correct error>
+MEDIUMBLOB     	MEDIUMBLOB     	ALL_NON_LOSSY            	<Correct value>
+MEDIUMBLOB     	LONGBLOB       	ALL_NON_LOSSY            	<Correct value>
+LONGBLOB       	TINYBLOB       	ALL_NON_LOSSY            	<Correct error>
+LONGBLOB       	BLOB           	ALL_NON_LOSSY            	<Correct error>
+LONGBLOB       	MEDIUMBLOB     	ALL_NON_LOSSY            	<Correct error>
+LONGBLOB       	LONGBLOB       	ALL_NON_LOSSY            	<Correct value>
+GEOMETRY       	BLOB           	ALL_NON_LOSSY            	<Correct error>
+BLOB           	GEOMETRY       	ALL_NON_LOSSY            	<Correct error>
+GEOMETRY       	GEOMETRY       	ALL_NON_LOSSY            	<Correct value>
+BIT(1)         	BIT(1)         	ALL_NON_LOSSY            	<Correct value>
+DATE           	DATE           	ALL_NON_LOSSY            	<Correct value>
+ENUM('master','	ENUM('master','	ALL_NON_LOSSY            	<Correct value>
+CHAR(10)       	ENUM('master','	ALL_NON_LOSSY            	<Correct error>
+CHAR(10)       	SET('master','s	ALL_NON_LOSSY            	<Correct error>
+ENUM('master','	CHAR(10)       	ALL_NON_LOSSY            	<Correct error>
+SET('master','s	CHAR(10)       	ALL_NON_LOSSY            	<Correct error>
+SET('master','s	SET('master','s	ALL_NON_LOSSY            	<Correct value>
+SET('master','s	SET('master','s	ALL_NON_LOSSY            	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_NON_LOSSY            	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_NON_LOSSY            	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_NON_LOSSY            	<Correct error>
+SET('0','1','2'	SET('0','1','2'	ALL_NON_LOSSY            	<Correct error>
+TINYINT        	TINYINT        	ALL_NON_LOSSY            	<Correct value>
+TINYINT        	SMALLINT       	ALL_NON_LOSSY            	<Correct value>
+TINYINT        	MEDIUMINT      	ALL_NON_LOSSY            	<Correct value>
+TINYINT        	INT            	ALL_NON_LOSSY            	<Correct value>
+TINYINT        	BIGINT         	ALL_NON_LOSSY            	<Correct value>
+SMALLINT       	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+SMALLINT       	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+SMALLINT       	TINYINT UNSIGNE	ALL_NON_LOSSY            	<Correct error>
+SMALLINT       	SMALLINT       	ALL_NON_LOSSY            	<Correct value>
+SMALLINT       	MEDIUMINT      	ALL_NON_LOSSY            	<Correct value>
+SMALLINT       	INT            	ALL_NON_LOSSY            	<Correct value>
+SMALLINT       	BIGINT         	ALL_NON_LOSSY            	<Correct value>
+MEDIUMINT      	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+MEDIUMINT      	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+MEDIUMINT      	TINYINT UNSIGNE	ALL_NON_LOSSY            	<Correct error>
+MEDIUMINT      	SMALLINT       	ALL_NON_LOSSY            	<Correct error>
+MEDIUMINT      	MEDIUMINT      	ALL_NON_LOSSY            	<Correct value>
+MEDIUMINT      	INT            	ALL_NON_LOSSY            	<Correct value>
+MEDIUMINT      	BIGINT         	ALL_NON_LOSSY            	<Correct value>
+INT            	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+INT            	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+INT            	TINYINT UNSIGNE	ALL_NON_LOSSY            	<Correct error>
+INT            	SMALLINT       	ALL_NON_LOSSY            	<Correct error>
+INT            	MEDIUMINT      	ALL_NON_LOSSY            	<Correct error>
+INT            	INT            	ALL_NON_LOSSY            	<Correct value>
+INT            	BIGINT         	ALL_NON_LOSSY            	<Correct value>
+BIGINT         	TINYINT        	ALL_NON_LOSSY            	<Correct error>
+BIGINT         	SMALLINT       	ALL_NON_LOSSY            	<Correct error>
+BIGINT         	MEDIUMINT      	ALL_NON_LOSSY            	<Correct error>
+BIGINT         	INT            	ALL_NON_LOSSY            	<Correct error>
+BIGINT         	BIGINT         	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	CHAR(20)       	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	CHAR(30)       	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	CHAR(10)       	ALL_NON_LOSSY            	<Correct error>
+CHAR(20)       	VARCHAR(20)    	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	VARCHAR(30)    	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	VARCHAR(10)    	ALL_NON_LOSSY            	<Correct error>
+CHAR(20)       	TINYTEXT       	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	TEXT           	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	MEDIUMTEXT     	ALL_NON_LOSSY            	<Correct value>
+CHAR(20)       	LONGTEXT       	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	VARCHAR(20)    	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	VARCHAR(30)    	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	VARCHAR(10)    	ALL_NON_LOSSY            	<Correct error>
+VARCHAR(20)    	CHAR(30)       	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	CHAR(10)       	ALL_NON_LOSSY            	<Correct error>
+VARCHAR(20)    	TINYTEXT       	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	TEXT           	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	MEDIUMTEXT     	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(20)    	LONGTEXT       	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(500)   	VARCHAR(500)   	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(500)   	VARCHAR(510)   	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(500)   	VARCHAR(255)   	ALL_NON_LOSSY            	<Correct error>
+VARCHAR(500)   	TINYTEXT       	ALL_NON_LOSSY            	<Correct error>
+VARCHAR(500)   	TEXT           	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(500)   	MEDIUMTEXT     	ALL_NON_LOSSY            	<Correct value>
+VARCHAR(500)   	LONGTEXT       	ALL_NON_LOSSY            	<Correct value>
+TINYTEXT       	VARCHAR(500)   	ALL_NON_LOSSY            	<Correct value>
+TEXT           	VARCHAR(500)   	ALL_NON_LOSSY            	<Correct error>
+MEDIUMTEXT     	VARCHAR(500)   	ALL_NON_LOSSY            	<Correct error>
+LONGTEXT       	VARCHAR(500)   	ALL_NON_LOSSY            	<Correct error>
+TINYTEXT       	CHAR(255)      	ALL_NON_LOSSY            	<Correct value>
+TINYTEXT       	CHAR(250)      	ALL_NON_LOSSY            	<Correct error>
+TEXT           	CHAR(255)      	ALL_NON_LOSSY            	<Correct error>
+MEDIUMTEXT     	CHAR(255)      	ALL_NON_LOSSY            	<Correct error>
+LONGTEXT       	CHAR(255)      	ALL_NON_LOSSY            	<Correct error>
+TINYTEXT       	TINYTEXT       	ALL_NON_LOSSY            	<Correct value>
+TINYTEXT       	TEXT           	ALL_NON_LOSSY            	<Correct value>
+TEXT           	TINYTEXT       	ALL_NON_LOSSY            	<Correct error>
+DECIMAL(10,5)  	DECIMAL(10,5)  	ALL_NON_LOSSY            	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,6)  	ALL_NON_LOSSY            	<Correct value>
+DECIMAL(10,5)  	DECIMAL(11,5)  	ALL_NON_LOSSY            	<Correct value>
+DECIMAL(10,5)  	DECIMAL(11,6)  	ALL_NON_LOSSY            	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,4)  	ALL_NON_LOSSY            	<Correct error>
+DECIMAL(10,5)  	DECIMAL(9,5)   	ALL_NON_LOSSY            	<Correct error>
+DECIMAL(10,5)  	DECIMAL(9,4)   	ALL_NON_LOSSY            	<Correct error>
+FLOAT          	DECIMAL(10,5)  	ALL_NON_LOSSY            	<Correct error>
+DOUBLE         	DECIMAL(10,5)  	ALL_NON_LOSSY            	<Correct error>
+DECIMAL(10,5)  	FLOAT          	ALL_NON_LOSSY            	<Correct error>
+DECIMAL(10,5)  	DOUBLE         	ALL_NON_LOSSY            	<Correct error>
+FLOAT          	FLOAT          	ALL_NON_LOSSY            	<Correct value>
+DOUBLE         	DOUBLE         	ALL_NON_LOSSY            	<Correct value>
+FLOAT          	DOUBLE         	ALL_NON_LOSSY            	<Correct value>
+DOUBLE         	FLOAT          	ALL_NON_LOSSY            	<Correct error>
+BIT(5)         	BIT(5)         	ALL_NON_LOSSY            	<Correct value>
+BIT(5)         	BIT(6)         	ALL_NON_LOSSY            	<Correct value>
+BIT(6)         	BIT(5)         	ALL_NON_LOSSY            	<Correct error>
+BIT(5)         	BIT(12)        	ALL_NON_LOSSY            	<Correct value>
+BIT(12)        	BIT(5)         	ALL_NON_LOSSY            	<Correct error>
+TINYBLOB       	TINYBLOB       	ALL_LOSSY                	<Correct value>
+TINYBLOB       	BLOB           	ALL_LOSSY                	<Correct error>
+TINYBLOB       	MEDIUMBLOB     	ALL_LOSSY                	<Correct error>
+TINYBLOB       	LONGBLOB       	ALL_LOSSY                	<Correct error>
+BLOB           	TINYBLOB       	ALL_LOSSY                	<Correct value>
+BLOB           	BLOB           	ALL_LOSSY                	<Correct value>
+BLOB           	MEDIUMBLOB     	ALL_LOSSY                	<Correct error>
+BLOB           	LONGBLOB       	ALL_LOSSY                	<Correct error>
+MEDIUMBLOB     	TINYBLOB       	ALL_LOSSY                	<Correct value>
+MEDIUMBLOB     	BLOB           	ALL_LOSSY                	<Correct value>
+MEDIUMBLOB     	MEDIUMBLOB     	ALL_LOSSY                	<Correct value>
+MEDIUMBLOB     	LONGBLOB       	ALL_LOSSY                	<Correct error>
+LONGBLOB       	TINYBLOB       	ALL_LOSSY                	<Correct value>
+LONGBLOB       	BLOB           	ALL_LOSSY                	<Correct value>
+LONGBLOB       	MEDIUMBLOB     	ALL_LOSSY                	<Correct value>
+LONGBLOB       	LONGBLOB       	ALL_LOSSY                	<Correct value>
+GEOMETRY       	BLOB           	ALL_LOSSY                	<Correct error>
+BLOB           	GEOMETRY       	ALL_LOSSY                	<Correct error>
+GEOMETRY       	GEOMETRY       	ALL_LOSSY                	<Correct value>
+BIT(1)         	BIT(1)         	ALL_LOSSY                	<Correct value>
+DATE           	DATE           	ALL_LOSSY                	<Correct value>
+ENUM('master','	ENUM('master','	ALL_LOSSY                	<Correct value>
+CHAR(10)       	ENUM('master','	ALL_LOSSY                	<Correct error>
+CHAR(10)       	SET('master','s	ALL_LOSSY                	<Correct error>
+ENUM('master','	CHAR(10)       	ALL_LOSSY                	<Correct error>
+SET('master','s	CHAR(10)       	ALL_LOSSY                	<Correct error>
+SET('master','s	SET('master','s	ALL_LOSSY                	<Correct value>
+SET('master','s	SET('master','s	ALL_LOSSY                	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY                	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY                	<Correct error>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY                	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY                	<Correct value>
+TINYINT        	TINYINT        	ALL_LOSSY                	<Correct value>
+TINYINT        	SMALLINT       	ALL_LOSSY                	<Correct error>
+TINYINT        	MEDIUMINT      	ALL_LOSSY                	<Correct error>
+TINYINT        	INT            	ALL_LOSSY                	<Correct error>
+TINYINT        	BIGINT         	ALL_LOSSY                	<Correct error>
+SMALLINT       	TINYINT        	ALL_LOSSY                	<Correct value>
+SMALLINT       	TINYINT        	ALL_LOSSY                	<Correct value>
+SMALLINT       	TINYINT UNSIGNE	ALL_LOSSY                	<Correct value>
+SMALLINT       	SMALLINT       	ALL_LOSSY                	<Correct value>
+SMALLINT       	MEDIUMINT      	ALL_LOSSY                	<Correct error>
+SMALLINT       	INT            	ALL_LOSSY                	<Correct error>
+SMALLINT       	BIGINT         	ALL_LOSSY                	<Correct error>
+MEDIUMINT      	TINYINT        	ALL_LOSSY                	<Correct value>
+MEDIUMINT      	TINYINT        	ALL_LOSSY                	<Correct value>
+MEDIUMINT      	TINYINT UNSIGNE	ALL_LOSSY                	<Correct value>
+MEDIUMINT      	SMALLINT       	ALL_LOSSY                	<Correct value>
+MEDIUMINT      	MEDIUMINT      	ALL_LOSSY                	<Correct value>
+MEDIUMINT      	INT            	ALL_LOSSY                	<Correct error>
+MEDIUMINT      	BIGINT         	ALL_LOSSY                	<Correct error>
+INT            	TINYINT        	ALL_LOSSY                	<Correct value>
+INT            	TINYINT        	ALL_LOSSY                	<Correct value>
+INT            	TINYINT UNSIGNE	ALL_LOSSY                	<Correct value>
+INT            	SMALLINT       	ALL_LOSSY                	<Correct value>
+INT            	MEDIUMINT      	ALL_LOSSY                	<Correct value>
+INT            	INT            	ALL_LOSSY                	<Correct value>
+INT            	BIGINT         	ALL_LOSSY                	<Correct error>
+BIGINT         	TINYINT        	ALL_LOSSY                	<Correct value>
+BIGINT         	SMALLINT       	ALL_LOSSY                	<Correct value>
+BIGINT         	MEDIUMINT      	ALL_LOSSY                	<Correct value>
+BIGINT         	INT            	ALL_LOSSY                	<Correct value>
+BIGINT         	BIGINT         	ALL_LOSSY                	<Correct value>
+CHAR(20)       	CHAR(20)       	ALL_LOSSY                	<Correct value>
+CHAR(20)       	CHAR(30)       	ALL_LOSSY                	<Correct error>
+CHAR(20)       	CHAR(10)       	ALL_LOSSY                	<Correct value>
+CHAR(20)       	VARCHAR(20)    	ALL_LOSSY                	<Correct error>
+CHAR(20)       	VARCHAR(30)    	ALL_LOSSY                	<Correct error>
+CHAR(20)       	VARCHAR(10)    	ALL_LOSSY                	<Correct value>
+CHAR(20)       	TINYTEXT       	ALL_LOSSY                	<Correct error>
+CHAR(20)       	TEXT           	ALL_LOSSY                	<Correct error>
+CHAR(20)       	MEDIUMTEXT     	ALL_LOSSY                	<Correct error>
+CHAR(20)       	LONGTEXT       	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	VARCHAR(20)    	ALL_LOSSY                	<Correct value>
+VARCHAR(20)    	VARCHAR(30)    	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	VARCHAR(10)    	ALL_LOSSY                	<Correct value>
+VARCHAR(20)    	CHAR(30)       	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	CHAR(10)       	ALL_LOSSY                	<Correct value>
+VARCHAR(20)    	TINYTEXT       	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	TEXT           	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	MEDIUMTEXT     	ALL_LOSSY                	<Correct error>
+VARCHAR(20)    	LONGTEXT       	ALL_LOSSY                	<Correct error>
+VARCHAR(500)   	VARCHAR(500)   	ALL_LOSSY                	<Correct value>
+VARCHAR(500)   	VARCHAR(510)   	ALL_LOSSY                	<Correct error>
+VARCHAR(500)   	VARCHAR(255)   	ALL_LOSSY                	<Correct value>
+VARCHAR(500)   	TINYTEXT       	ALL_LOSSY                	<Correct value>
+VARCHAR(500)   	TEXT           	ALL_LOSSY                	<Correct error>
+VARCHAR(500)   	MEDIUMTEXT     	ALL_LOSSY                	<Correct error>
+VARCHAR(500)   	LONGTEXT       	ALL_LOSSY                	<Correct error>
+TINYTEXT       	VARCHAR(500)   	ALL_LOSSY                	<Correct error>
+TEXT           	VARCHAR(500)   	ALL_LOSSY                	<Correct value>
+MEDIUMTEXT     	VARCHAR(500)   	ALL_LOSSY                	<Correct value>
+LONGTEXT       	VARCHAR(500)   	ALL_LOSSY                	<Correct value>
+TINYTEXT       	CHAR(255)      	ALL_LOSSY                	<Correct error>
+TINYTEXT       	CHAR(250)      	ALL_LOSSY                	<Correct value>
+TEXT           	CHAR(255)      	ALL_LOSSY                	<Correct value>
+MEDIUMTEXT     	CHAR(255)      	ALL_LOSSY                	<Correct value>
+LONGTEXT       	CHAR(255)      	ALL_LOSSY                	<Correct value>
+TINYTEXT       	TINYTEXT       	ALL_LOSSY                	<Correct value>
+TINYTEXT       	TEXT           	ALL_LOSSY                	<Correct error>
+TEXT           	TINYTEXT       	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,5)  	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,6)  	ALL_LOSSY                	<Correct error>
+DECIMAL(10,5)  	DECIMAL(11,5)  	ALL_LOSSY                	<Correct error>
+DECIMAL(10,5)  	DECIMAL(11,6)  	ALL_LOSSY                	<Correct error>
+DECIMAL(10,5)  	DECIMAL(10,4)  	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	DECIMAL(9,5)   	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	DECIMAL(9,4)   	ALL_LOSSY                	<Correct value>
+FLOAT          	DECIMAL(10,5)  	ALL_LOSSY                	<Correct value>
+DOUBLE         	DECIMAL(10,5)  	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	FLOAT          	ALL_LOSSY                	<Correct value>
+DECIMAL(10,5)  	DOUBLE         	ALL_LOSSY                	<Correct value>
+FLOAT          	FLOAT          	ALL_LOSSY                	<Correct value>
+DOUBLE         	DOUBLE         	ALL_LOSSY                	<Correct value>
+FLOAT          	DOUBLE         	ALL_LOSSY                	<Correct error>
+DOUBLE         	FLOAT          	ALL_LOSSY                	<Correct value>
+BIT(5)         	BIT(5)         	ALL_LOSSY                	<Correct value>
+BIT(5)         	BIT(6)         	ALL_LOSSY                	<Correct error>
+BIT(6)         	BIT(5)         	ALL_LOSSY                	<Correct value>
+BIT(5)         	BIT(12)        	ALL_LOSSY                	<Correct error>
+BIT(12)        	BIT(5)         	ALL_LOSSY                	<Correct value>
+TINYBLOB       	TINYBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYBLOB       	BLOB           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYBLOB       	MEDIUMBLOB     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYBLOB       	LONGBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BLOB           	TINYBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BLOB           	BLOB           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BLOB           	MEDIUMBLOB     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BLOB           	LONGBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMBLOB     	TINYBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMBLOB     	BLOB           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMBLOB     	MEDIUMBLOB     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMBLOB     	LONGBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGBLOB       	TINYBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGBLOB       	BLOB           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGBLOB       	MEDIUMBLOB     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGBLOB       	LONGBLOB       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+GEOMETRY       	BLOB           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+BLOB           	GEOMETRY       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+GEOMETRY       	GEOMETRY       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(1)         	BIT(1)         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DATE           	DATE           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+ENUM('master','	ENUM('master','	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(10)       	ENUM('master','	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+CHAR(10)       	SET('master','s	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+ENUM('master','	CHAR(10)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+SET('master','s	CHAR(10)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct error>
+SET('master','s	SET('master','s	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SET('master','s	SET('master','s	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SET('0','1','2'	SET('0','1','2'	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYINT        	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYINT        	SMALLINT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYINT        	MEDIUMINT      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYINT        	INT            	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYINT        	BIGINT         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	TINYINT UNSIGNE	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	SMALLINT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	MEDIUMINT      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	INT            	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+SMALLINT       	BIGINT         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	TINYINT UNSIGNE	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	SMALLINT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	MEDIUMINT      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	INT            	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMINT      	BIGINT         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	TINYINT UNSIGNE	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	SMALLINT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	MEDIUMINT      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	INT            	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+INT            	BIGINT         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIGINT         	TINYINT        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIGINT         	SMALLINT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIGINT         	MEDIUMINT      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIGINT         	INT            	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIGINT         	BIGINT         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	CHAR(20)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	CHAR(30)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	CHAR(10)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	VARCHAR(20)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	VARCHAR(30)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	VARCHAR(10)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	TINYTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	TEXT           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	MEDIUMTEXT     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+CHAR(20)       	LONGTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	VARCHAR(20)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	VARCHAR(30)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	VARCHAR(10)    	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	CHAR(30)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	CHAR(10)       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	TINYTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	TEXT           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	MEDIUMTEXT     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(20)    	LONGTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	VARCHAR(500)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	VARCHAR(510)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	VARCHAR(255)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	TINYTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	TEXT           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	MEDIUMTEXT     	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+VARCHAR(500)   	LONGTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYTEXT       	VARCHAR(500)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TEXT           	VARCHAR(500)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMTEXT     	VARCHAR(500)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGTEXT       	VARCHAR(500)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYTEXT       	CHAR(255)      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYTEXT       	CHAR(250)      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TEXT           	CHAR(255)      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+MEDIUMTEXT     	CHAR(255)      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+LONGTEXT       	CHAR(255)      	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYTEXT       	TINYTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TINYTEXT       	TEXT           	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+TEXT           	TINYTEXT       	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,5)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,6)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(11,5)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(11,6)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(10,4)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(9,5)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DECIMAL(9,4)   	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+FLOAT          	DECIMAL(10,5)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DOUBLE         	DECIMAL(10,5)  	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	FLOAT          	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DECIMAL(10,5)  	DOUBLE         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+FLOAT          	FLOAT          	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DOUBLE         	DOUBLE         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+FLOAT          	DOUBLE         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DOUBLE         	FLOAT          	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(5)         	BIT(5)         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(5)         	BIT(6)         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(6)         	BIT(5)         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(5)         	BIT(12)        	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+BIT(12)        	BIT(5)         	ALL_LOSSY,ALL_NON_LOSSY  	<Correct value>
+DROP TABLE type_conversions;
+DROP TABLE t1;
+set global slave_type_conversions = @saved_slave_type_conversions;
+include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/t/rpl_bug31076.test'
--- Percona-Server/mysql-test/suite/rpl/t/rpl_bug31076.test	2010-12-19 17:07:28 +0000
+++ Percona-Server/mysql-test/suite/rpl/t/rpl_bug31076.test	2012-02-22 07:32:24 +0000
@@ -1,5 +1,8 @@
 source include/master-slave.inc;
 
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
+
 CREATE DATABASE track;
 USE track;
 
@@ -130,8 +133,11 @@
 SELECT * FROM visits;
 SELECT * FROM visits_events;
 
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
+
 # Cleanup
 DROP DATABASE track;
 sync_slave_with_master;
+
 --echo End of 5.1 tests
 --source include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/t/rpl_colSize.test'
--- Percona-Server/mysql-test/suite/rpl/t/rpl_colSize.test	2010-12-19 17:07:28 +0000
+++ Percona-Server/mysql-test/suite/rpl/t/rpl_colSize.test	2012-02-22 07:32:24 +0000
@@ -18,6 +18,9 @@
 STOP SLAVE;
 RESET SLAVE;
 
+SET @saved_slave_type_conversions = @@slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = 'ALL_NON_LOSSY';
+
 eval CREATE TABLE t1 (
   a float     (47),
   b double    (143,9),
@@ -217,5 +220,7 @@
 DROP TABLE t1;
 sync_slave_with_master;
 
+SET GLOBAL SLAVE_TYPE_CONVERSIONS = @saved_slave_type_conversions;
+
 # END 5.1 Test Case
 --source include/rpl_end.inc

=== modified file 'Percona-Server/mysql-test/suite/rpl/t/rpl_row_basic_3innodb.test'
--- Percona-Server/mysql-test/suite/rpl/t/rpl_row_basic_3innodb.test	2010-12-19 17:07:28 +0000
+++ Percona-Server/mysql-test/suite/rpl/t/rpl_row_basic_3innodb.test	2012-02-22 07:32:24 +0000
@@ -2,6 +2,8 @@
 -- source include/have_binlog_format_row.inc
 -- source include/master-slave.inc
 
+connection slave;
+let $bit_field_special = ALL_LOSSY;
 let $type= 'INNODB' ;
 let $extra_index= ;
 -- source extra/rpl_tests/rpl_row_basic.test

=== modified file 'Percona-Server/mysql-test/suite/rpl/t/rpl_row_colSize.test'
--- Percona-Server/mysql-test/suite/rpl/t/rpl_row_colSize.test	2011-02-23 09:31:37 +0000
+++ Percona-Server/mysql-test/suite/rpl/t/rpl_row_colSize.test	2012-02-22 07:32:24 +0000
@@ -9,6 +9,10 @@
 -- source include/master-slave.inc
 -- source include/have_binlog_format_row.inc
 
+--disable_query_log
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+--enable_query_log
+
 --disable_warnings
 DROP TABLE IF EXISTS t1;
 --enable_warnings

=== added file 'Percona-Server/mysql-test/suite/rpl/t/rpl_typeconv.test'
--- Percona-Server/mysql-test/suite/rpl/t/rpl_typeconv.test	1970-01-01 00:00:00 +0000
+++ Percona-Server/mysql-test/suite/rpl/t/rpl_typeconv.test	2012-02-22 07:32:24 +0000
@@ -0,0 +1,75 @@
+--source include/have_binlog_format_row.inc
+--source include/master-slave.inc
+
+connection slave;
+set @saved_slave_type_conversions = @@global.slave_type_conversions;
+CREATE TABLE type_conversions (
+       TestNo INT AUTO_INCREMENT PRIMARY KEY,
+       Source TEXT,
+       Target TEXT,
+       Flags TEXT,
+       On_Master TEXT,
+       On_Slave TEXT,
+       Expected TEXT,
+       Compare INT,
+       Error TEXT);
+
+SELECT @@global.slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+SELECT @@global.slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+SELECT @@global.slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY';
+SELECT @@global.slave_type_conversions;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY';
+SELECT @@global.slave_type_conversions;
+--error ER_WRONG_VALUE_FOR_VAR
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY,NONEXISTING_BIT';
+SELECT @@global.slave_type_conversions;
+
+# ignore error in mysqld.err
+--disable_query_log
+call mtr.add_suppression("Slave SQL.*Column.*of table.*cannot be converted from type.*to type.* 1677");
+--enable_query_log
+
+# Checking strict interpretation of type conversions
+connection slave;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+source extra/rpl_tests/type_conversions.test;
+
+# Checking lossy integer type conversions
+connection slave;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+source extra/rpl_tests/type_conversions.test;
+
+# Checking non-lossy integer type conversions
+connection slave;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY';
+source extra/rpl_tests/type_conversions.test;
+
+# Checking all type conversions
+connection slave;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_LOSSY,ALL_NON_LOSSY';
+source extra/rpl_tests/type_conversions.test;
+
+connection slave;
+--echo **** Result of conversions ****
+disable_query_log;
+SELECT RPAD(Source, 15, ' ') AS Source_Type,
+       RPAD(Target, 15, ' ') AS Target_Type,
+       RPAD(Flags, 25, ' ') AS All_Type_Conversion_Flags,
+       IF(Compare IS NULL AND Error IS NOT NULL, '<Correct error>',
+          IF(Compare, '<Correct value>',
+             CONCAT("'", On_Slave, "' != '", Expected, "'")))
+         AS Value_On_Slave
+  FROM type_conversions;
+enable_query_log;
+DROP TABLE type_conversions;
+
+connection master;
+DROP TABLE t1;
+sync_slave_with_master;
+
+set global slave_type_conversions = @saved_slave_type_conversions;
+
+source include/rpl_end.inc;

=== modified file 'Percona-Server/sql/field.cc'
--- Percona-Server/sql/field.cc	2011-07-03 15:47:37 +0000
+++ Percona-Server/sql/field.cc	2012-02-22 07:32:24 +0000
@@ -60,6 +60,8 @@
 #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 DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index)))
 
+#define FLAGSTR(S,F) ((S) & (F) ? #F " " : "")
+
 /*
   Rules for merging different types of fields in UNION
 
@@ -998,6 +1000,23 @@
 
 
 /**
+   Function to compare two unsigned integers for their relative order.
+   Used below. In an anonymous namespace to not clash with definitions
+   in other files.
+ */
+namespace
+{
+  int compare(unsigned int a, unsigned int b)
+  {
+    if (a < b)
+      return -1;
+    if (b < a)
+      return 1;
+    return 0;
+  }
+}
+
+/**
   Detect Item_result by given field type of UNION merge result.
 
   @param field_type  given field type
@@ -1368,24 +1387,48 @@
 /**
    Check to see if field size is compatible with destination.
 
-   This method is used in row-based replication to verify that the slave's
-   field size is less than or equal to the master's field size. The 
-   encoded field metadata (from the master or source) is decoded and compared
-   to the size of this field (the slave or destination). 
+   This method is used in row-based replication to verify that the
+   slave's field size is less than or equal to the master's field
+   size. The encoded field metadata (from the master or source) is
+   decoded and compared to the size of this field (the slave or
+   destination).
+
+   @note
+
+   The comparison is made so that if the source data (from the master)
+   is less than the target data (on the slave), -1 is returned in @c
+   <code>*order_var</code>. This implies that a conversion is
+   necessary, but that it is lossy and can result in truncation of the
+   value.
+
+   If the source data is strictly greater than the target data, 1 is
+   returned in <code>*order_var</code>. This implies that the source
+   type can is contained in the target type and that a conversion is
+   necessary but is non-lossy.
+
+   If no conversion is required to fit the source type in the target
+   type, 0 is returned in <code>*order_var</code>.
 
    @param   field_metadata   Encoded size in field metadata
    @param   mflags           Flags from the table map event for the table.
-
-   @retval 0 if this field's size is < the source field's size
-   @retval 1 if this field's size is >= the source field's size
+   @param   order_var        Pointer to variable where the order
+                             between the source field and this field
+                             will be returned.
+   
+   @return @c true if this field's size is compatible with the
+   master's field size, @c false otherwise.
 */
-int Field::compatible_field_size(uint field_metadata,
-                                 const Relay_log_info *rli_arg __attribute__((unused)),
-                                 uint16 mflags __attribute__((unused)))
+bool Field::compatible_field_size(uint field_metadata,
+                                  Relay_log_info *__attribute__((unused)),
+                                  uint16 __attribute__((unused)),
+                                  int *order_var)
 {
   uint const source_size= pack_length_from_metadata(field_metadata);
   uint const destination_size= row_pack_length();
-  return (source_size <= destination_size);
+  DBUG_PRINT("debug", ("real_type: %d, source_size: %u, destination_size: %u",
+                       real_type(), source_size, destination_size));
+  *order_var= compare(source_size, destination_size);
+  return true;
 }
 
 
@@ -2869,33 +2912,45 @@
 
 
 /**
-   Check to see if field size is compatible with destination.
-
-   This method is used in row-based replication to verify that the slave's
-   field size is less than or equal to the master's field size. The 
-   encoded field metadata (from the master or source) is decoded and compared
-   to the size of this field (the slave or destination). 
-
+   This method is used in row-based replication to verify that the
+   slave's field size is less than or equal to the master's field
+   size. The encoded field metadata (from the master or source) is
+   decoded and compared to the size of this field (the slave or
+   destination).
+
+   @note
+
+   The comparison is made so that if the source data (from the master)
+   is less than the target data (on the slave), -1 is returned in @c
+   <code>*order_var</code>. This implies that a conversion is
+   necessary, but that it is lossy and can result in truncation of the
+   value.
+
+   If the source data is strictly greater than the target data, 1 is
+   returned in <code>*order_var</code>. This implies that the source
+   type can is contained in the target type and that a conversion is
+   necessary but is non-lossy.
+
+   If no conversion is required to fit the source type in the target
+   type, 0 is returned in <code>*order_var</code>. 
    @param   field_metadata   Encoded size in field metadata
-
-   @retval 0 if this field's size is < the source field's size
-   @retval 1 if this field's size is >= the source field's size
+   @param   order_var        Pointer to variable where the order
+                             between the source field and this field
+                             will be returned.
+   
+   @return @c true if this field's size is compatible with the
+   master's field size, @c false otherwise.
 */
-int Field_new_decimal::compatible_field_size(uint field_metadata,
-                                             const Relay_log_info * __attribute__((unused)),
-                                             uint16 mflags __attribute__((unused)))
+bool Field_new_decimal::compatible_field_size(uint field_metadata,
+                                              Relay_log_info *__attribute__((unused)),
+                                              uint16 __attribute__((unused)),
+                                              int *order_var)
 {
-  int compatible= 0;
-  uint const source_precision= (field_metadata >> 8U) & 0x00ff;
-  uint const source_decimal= field_metadata & 0x00ff; 
-  uint const source_size= my_decimal_get_binary_size(source_precision, 
-                                                     source_decimal);
-  uint const destination_size= row_pack_length();
-  compatible= (source_size <= destination_size);
-  if (compatible)
-    compatible= (source_precision <= precision) &&
-                (source_decimal <= decimals());
-  return (compatible);
+  uint const src_precision= (field_metadata >> 8U) & 0x00ff;
+  uint const src_decimal=   field_metadata & 0x00ff;
+  int order=                compare(src_precision, precision);
+  *order_var=               order != 0 ? order : compare(src_decimal, dec);
+  return true;
 }
 
 
@@ -6645,17 +6700,50 @@
 }
 #endif
 
-int Field_string::compatible_field_size(uint field_metadata,
-                                        const Relay_log_info *rli_arg,
-                                        uint16 mflags __attribute__((unused)))
+/**
+   This method is used in row-based replication to verify that the
+   slave's field size is less than or equal to the master's field
+   size. The encoded field metadata (from the master or source) is
+   decoded and compared to the size of this field (the slave or
+   destination).
+
+   @note
+
+   The comparison is made so that if the source data (from the master)
+   is less than the target data (on the slave), -1 is returned in @c
+   <code>*order_var</code>. This implies that a conversion is
+   necessary, but that it is lossy and can result in truncation of the
+   value.
+
+   If the source data is strictly greater than the target data, 1 is
+   returned in <code>*order_var</code>. This implies that the source
+   type can is contained in the target type and that a conversion is
+   necessary but is non-lossy.
+
+   If no conversion is required to fit the source type in the target
+   type, 0 is returned in <code>*order_var</code>.
+   @param   field_metadata   Encoded size in field metadata
+   @param   rli_arg          Relay log information
+   @param   order_var        Pointer to variable where the order
+                             between the source field and this field
+                             will be returned.
+
+   @return @c true if this field's size is compatible with the
+   master's field size, @c false otherwise.
+*/
+bool
+Field_string::compatible_field_size(uint field_metadata,
+                                    Relay_log_info *rli_arg,
+                                    uint16 mflags __attribute__((unused)),
+                                    int *order_var)
 {
 #ifdef HAVE_REPLICATION
   const Check_field_param check_param = { this };
   if (rpl_master_has_bug(rli_arg, 37426, TRUE,
                          check_field_for_37426, &check_param))
-    return FALSE;                        // Not compatible field sizes
+    return FALSE;                                // Not compatible field sizes
 #endif
-  return Field::compatible_field_size(field_metadata, rli_arg, mflags);
+  return Field::compatible_field_size(field_metadata, rli_arg, mflags, order_var);
 }
 
 
@@ -6717,6 +6805,8 @@
 {
   uint length=      min(field_length,max_length);
   uint local_char_length= max_length/field_charset->mbmaxlen;
+  DBUG_PRINT("debug", ("Packing field '%s' - length: %u ", field_name, length));
+
   if (length > local_char_length)
     local_char_length= my_charpos(field_charset, from, from+length,
                                   local_char_length);
@@ -7563,6 +7653,7 @@
                  cs),
    packlength(blob_pack_length)
 {
+  DBUG_ASSERT(blob_pack_length <= 4); // Only pack lengths 1-4 supported currently
   flags|= BLOB_FLAG;
   share->blob_fields++;
   /* TODO: why do not fill table->s->blob_field array here? */
@@ -7973,8 +8064,10 @@
 */
 int Field_blob::do_save_field_metadata(uchar *metadata_ptr)
 {
+  DBUG_ENTER("Field_blob::do_save_field_metadata");
   *metadata_ptr= pack_length_no_ptr();
-  return 1;
+  DBUG_PRINT("debug", ("metadata: %u (pack_length_no_ptr)", *metadata_ptr));
+  DBUG_RETURN(1);
 }
 
 
@@ -8926,6 +9019,9 @@
     bit_ptr(bit_ptr_arg), bit_ofs(bit_ofs_arg), bit_len(len_arg & 7),
     bytes_in_rec(len_arg / 8)
 {
+  DBUG_ENTER("Field_bit::Field_bit");
+  DBUG_PRINT("enter", ("ptr_arg: %p, null_ptr_arg: %p, len_arg: %u, bit_len: %u, bytes_in_rec: %u",
+                       ptr_arg, null_ptr_arg, len_arg, bit_len, bytes_in_rec));
   flags|= UNSIGNED_FLAG;
   /*
     Ensure that Field::eq() can distinguish between two different bit fields.
@@ -8933,6 +9029,7 @@
   */
   if (!null_ptr_arg)
     null_bit= bit_ofs_arg;
+  DBUG_VOID_RETURN;
 }
 
 
@@ -9217,6 +9314,9 @@
 */
 int Field_bit::do_save_field_metadata(uchar *metadata_ptr)
 {
+  DBUG_ENTER("Field_bit::do_save_field_metadata");
+  DBUG_PRINT("debug", ("bit_len: %d, bytes_in_rec: %d",
+                       bit_len, bytes_in_rec));
   /*
     Since this class and Field_bit_as_char have different ideas of
     what should be stored here, we compute the values of the metadata
@@ -9224,7 +9324,7 @@
    */
   metadata_ptr[0]= field_length % 8;
   metadata_ptr[1]= field_length / 8;
-  return 2;
+  DBUG_RETURN(2);
 }
 
 
@@ -9250,25 +9350,48 @@
 
 
 /**
-   Check to see if field size is compatible with destination.
-
-   This method is used in row-based replication to verify that the slave's
-   field size is less than or equal to the master's field size. The 
-   encoded field metadata (from the master or source) is decoded and compared
-   to the size of this field (the slave or destination). 
-
+   This method is used in row-based replication to verify that the
+   slave's field size is less than or equal to the master's field
+   size. The encoded field metadata (from the master or source) is
+   decoded and compared to the size of this field (the slave or
+   destination).
+
+   @note
+
+   The comparison is made so that if the source data (from the master)
+   is less than the target data (on the slave), -1 is returned in @c
+   <code>*order_var</code>. This implies that a conversion is
+   necessary, but that it is lossy and can result in truncation of the
+   value.
+
+   If the source data is strictly greater than the target data, 1 is
+   returned in <code>*order_var</code>. This implies that the source
+   type can is contained in the target type and that a conversion is
+   necessary but is non-lossy.
+
+   If no conversion is required to fit the source type in the target
+   type, 0 is returned in <code>*order_var</code>.
    @param   field_metadata   Encoded size in field metadata
+   @param   mflags           Flags from the table map event for the table.
+   @param   order_var        Pointer to variable where the order
+                             between the source field and this field
+                             will be returned.
 
-   @retval 0 if this field's size is < the source field's size
-   @retval 1 if this field's size is >= the source field's size
+   @return @c true if this field's size is compatible with the
+   master's field size, @c false otherwise.
 */
-int Field_bit::compatible_field_size(uint field_metadata,
-                                     const Relay_log_info * __attribute__((unused)),
-                                     uint16 mflags)
+bool
+Field_bit::compatible_field_size(uint field_metadata,
+                                 Relay_log_info *__attribute__((unused)),
+                                 uint16 mflags, int *order_var)
 {
-  uint from_bit_len= 8 * (field_metadata >> 8) + (field_metadata & 0xff);
+  DBUG_ENTER("Field_bit::compatible_field_size");
+  DBUG_ASSERT((field_metadata >> 16) == 0);
+  uint from_bit_len=
+    8 * (field_metadata >> 8) + (field_metadata & 0xff);
   uint to_bit_len= max_display_length();
-
+  DBUG_PRINT("debug", ("from_bit_len: %u, to_bit_len: %u",
+                       from_bit_len, to_bit_len));
   /*
     If the bit length exact flag is clear, we are dealing with an old
     master, so we allow some less strict behaviour if replicating by
@@ -9276,13 +9399,15 @@
 
     We do this by computing the number of bytes to store the field
     instead, and then compare the result.
-   */
-  if (!(mflags & Table_map_log_event::TM_BIT_LEN_EXACT_F)) {
+  */
+  if (!(mflags & Table_map_log_event::TM_BIT_LEN_EXACT_F))
+  {
     from_bit_len= (from_bit_len + 7) / 8;
     to_bit_len= (to_bit_len + 7) / 8;
   }
 
-  return from_bit_len <= to_bit_len;
+  *order_var= compare(from_bit_len, to_bit_len);
+  DBUG_RETURN(TRUE);
 }
 
 
@@ -9348,8 +9473,15 @@
 Field_bit::unpack(uchar *to, const uchar *from, uint param_data,
                   bool low_byte_first __attribute__((unused)))
 {
+  DBUG_ENTER("Field_bit::unpack");
+  DBUG_PRINT("enter", ("to: %p, from: %p, param_data: 0x%x",
+                       to, from, param_data));
+  DBUG_PRINT("debug", ("bit_ptr: %p, bit_len: %u, bit_ofs: %u",
+                       bit_ptr, bit_len, bit_ofs));
   uint const from_len= (param_data >> 8U) & 0x00ff;
   uint const from_bit_len= param_data & 0x00ff;
+  DBUG_PRINT("debug", ("from_len: %u, from_bit_len: %u",
+                       from_len, from_bit_len));
   /*
     If the parameter data is zero (i.e., undefined), or if the master
     and slave have the same sizes, then use the old unpack() method.
@@ -9370,7 +9502,7 @@
       from++;
     }
     memcpy(to, from, bytes_in_rec);
-    return from + bytes_in_rec;
+    DBUG_RETURN(from + bytes_in_rec);
   }
 
   /*
@@ -9396,7 +9528,7 @@
   bitmap_set_bit(table->write_set,field_index);
   store(value, new_len, system_charset_info);
   my_afree(value);
-  return from + len;
+  DBUG_RETURN(from + len);
 }
 
 
@@ -9525,8 +9657,11 @@
 */
 void Create_field::init_for_tmp_table(enum_field_types sql_type_arg,
                                       uint32 length_arg, uint32 decimals_arg,
-                                      bool maybe_null, bool is_unsigned)
+                                      bool maybe_null, bool is_unsigned,
+                                      uint pack_length)
 {
+  DBUG_ENTER("Create_field::init_for_tmp_table");
+
   field_name= "";
   sql_type= sql_type_arg;
   char_length= length= length_arg;;
@@ -9534,10 +9669,92 @@
   interval= 0;
   charset= &my_charset_bin;
   geom_type= Field::GEOM_GEOMETRY;
-  pack_flag= (FIELDFLAG_NUMBER |
-              ((decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT) |
-              (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
-              (is_unsigned ? 0 : FIELDFLAG_DECIMAL));
+
+  DBUG_PRINT("enter", ("sql_type: %d, length: %u, pack_length: %u",
+                       sql_type_arg, length_arg, pack_length));
+
+  /*
+    These pack flags are crafted to get it correctly through the
+    branches of make_field().
+   */
+  switch (sql_type_arg)
+  {
+  case MYSQL_TYPE_VARCHAR:
+  case MYSQL_TYPE_VAR_STRING:
+  case MYSQL_TYPE_STRING:
+  case MYSQL_TYPE_SET:
+    pack_flag= 0;
+    break;
+
+  case MYSQL_TYPE_GEOMETRY:
+    pack_flag= FIELDFLAG_GEOM;
+    break;
+
+  case MYSQL_TYPE_ENUM:
+    pack_flag= FIELDFLAG_INTERVAL;
+    break;
+
+  case MYSQL_TYPE_DECIMAL:
+  case MYSQL_TYPE_NEWDECIMAL:
+  case MYSQL_TYPE_FLOAT:
+  case MYSQL_TYPE_DOUBLE:
+    pack_flag= FIELDFLAG_DECIMAL | FIELDFLAG_NUMBER |
+      (decimals_arg & FIELDFLAG_MAX_DEC) << FIELDFLAG_DEC_SHIFT;
+    break;
+
+  case MYSQL_TYPE_TINY_BLOB:
+  case MYSQL_TYPE_MEDIUM_BLOB:
+  case MYSQL_TYPE_LONG_BLOB:
+  case MYSQL_TYPE_BLOB:
+    pack_flag= FIELDFLAG_BLOB;
+    break;
+
+  case MYSQL_TYPE_BIT:
+    pack_flag= FIELDFLAG_NUMBER | FIELDFLAG_TREAT_BIT_AS_CHAR;
+    break;
+
+  default:
+    pack_flag= FIELDFLAG_NUMBER;
+    break;
+  }
+
+  /*
+    Set the pack flag correctly for the blob-like types. This sets the
+    packtype to something that make_field can use. If the pack type is
+    not set correctly, the packlength will be reeeeally wierd (like
+    129 or so).
+   */
+  switch (sql_type_arg)
+  {
+  case MYSQL_TYPE_ENUM:
+  case MYSQL_TYPE_SET:
+  case MYSQL_TYPE_TINY_BLOB:
+  case MYSQL_TYPE_MEDIUM_BLOB:
+  case MYSQL_TYPE_LONG_BLOB:
+  case MYSQL_TYPE_BLOB:
+  case MYSQL_TYPE_GEOMETRY:
+    // If you are going to use the above types, you have to pass a
+    // pack_length as parameter. Assert that is really done.
+    DBUG_ASSERT(pack_length != ~0U);
+    pack_flag|= pack_length_to_packflag(pack_length);
+    break;
+  default:
+    /* Nothing */
+    break;
+  }
+
+  pack_flag|=
+    (maybe_null ? FIELDFLAG_MAYBE_NULL : 0) |
+    (is_unsigned ? 0 : FIELDFLAG_DECIMAL);
+
+  DBUG_PRINT("debug", ("pack_flag: %s%s%s%s%s, pack_type: %d",
+                       FLAGSTR(pack_flag, FIELDFLAG_BINARY),
+                       FLAGSTR(pack_flag, FIELDFLAG_NUMBER),
+                       FLAGSTR(pack_flag, FIELDFLAG_INTERVAL),
+                       FLAGSTR(pack_flag, FIELDFLAG_GEOM),
+                       FLAGSTR(pack_flag, FIELDFLAG_BLOB),
+                       f_packtype(pack_flag)));
+  DBUG_VOID_RETURN;
 }
 
 
@@ -10044,6 +10261,14 @@
   default: break;
   }
 
+  DBUG_PRINT("debug", ("field_type: %d, field_length: %u, interval: %p, pack_flag: %s%s%s%s%s",
+                       field_type, field_length, interval,
+                       FLAGSTR(pack_flag, FIELDFLAG_BINARY),
+                       FLAGSTR(pack_flag, FIELDFLAG_INTERVAL),
+                       FLAGSTR(pack_flag, FIELDFLAG_NUMBER),
+                       FLAGSTR(pack_flag, FIELDFLAG_PACK),
+                       FLAGSTR(pack_flag, FIELDFLAG_BLOB)));
+
   if (f_is_alpha(pack_flag))
   {
     if (!f_is_packed(pack_flag))

=== modified file 'Percona-Server/sql/field.h'
--- Percona-Server/sql/field.h	2011-11-18 13:47:11 +0000
+++ Percona-Server/sql/field.h	2012-02-22 07:32:24 +0000
@@ -171,22 +171,13 @@
     table, which is located on disk).
   */
   virtual uint32 pack_length_in_rec() const { return pack_length(); }
-  virtual int compatible_field_size(uint field_metadata,
-                                    const Relay_log_info *, uint16 mflags);
+  virtual bool compatible_field_size(uint metadata, Relay_log_info *rli,
+                                     uint16 mflags, int *order);
   virtual uint pack_length_from_metadata(uint field_metadata)
-  { return field_metadata; }
-  /*
-    This method is used to return the size of the data in a row-based
-    replication row record. The default implementation of returning 0 is
-    designed to allow fields that do not use metadata to return TRUE (1)
-    from compatible_field_size() which uses this function in the comparison.
-    The default value for field metadata for fields that do not have 
-    metadata is 0. Thus, 0 == 0 means the fields are compatible in size.
-
-    Note: While most classes that override this method return pack_length(),
-    the classes Field_string, Field_varstring, and Field_blob return 
-    field_length + 1, field_length, and pack_length_no_ptr() respectfully.
-  */
+  {
+    DBUG_ENTER("Field::pack_length_from_metadata");
+    DBUG_RETURN(field_metadata);
+  }
   virtual uint row_pack_length() { return 0; }
   virtual int save_field_metadata(uchar *first_byte)
   { return do_save_field_metadata(first_byte); }
@@ -646,6 +637,17 @@
   uint size_of() const { return sizeof(*this); }
   bool eq_def(Field *field);
   int store_decimal(const my_decimal *);
+  uint row_pack_length()
+  {
+    return pack_length();
+  }
+  uint32 pack_length_from_metadata(uint field_metadata)
+  {
+    uint32 length= pack_length();
+    DBUG_PRINT("result", ("pack_length_from_metadata(%d): %u",
+                          field_metadata, length));
+    return length;
+  }
   my_decimal *val_decimal(my_decimal *);
   uint is_equal(Create_field *new_field);
   int check_int(CHARSET_INFO *cs, const char *str, int length,
@@ -812,8 +814,8 @@
   uint32 pack_length() const { return (uint32) bin_size; }
   uint pack_length_from_metadata(uint field_metadata);
   uint row_pack_length() { return pack_length(); }
-  int compatible_field_size(uint field_metadata,
-                            const Relay_log_info *rli, uint16 mflags);
+  bool compatible_field_size(uint field_metadata, Relay_log_info *rli,
+                             uint16 mflags, int *order_var);
   uint is_equal(Create_field *new_field);
   virtual const uchar *unpack(uchar* to, const uchar *from,
                               uint param_data, bool low_byte_first);
@@ -1508,9 +1510,12 @@
       return row_pack_length();
     return (((field_metadata >> 4) & 0x300) ^ 0x300) + (field_metadata & 0x00ff);
   }
-  int compatible_field_size(uint field_metadata,
-                            const Relay_log_info *rli, uint16 mflags);
-  uint row_pack_length() { return (field_length + 1); }
+  bool compatible_field_size(uint field_metadata, Relay_log_info *rli,
+                             uint16 mflags, int *order_var);
+  uint row_pack_length()
+  {
+    return field_length;
+  }
   int pack_cmp(const uchar *a,const uchar *b,uint key_length,
                my_bool insert_or_update);
   int pack_cmp(const uchar *b,uint key_length,my_bool insert_or_update);
@@ -1977,8 +1982,8 @@
   uint pack_length_from_metadata(uint field_metadata);
   uint row_pack_length()
   { return (bytes_in_rec + ((bit_len > 0) ? 1 : 0)); }
-  int compatible_field_size(uint field_metadata,
-                            const Relay_log_info *rli, uint16 mflags);
+  bool compatible_field_size(uint metadata, Relay_log_info *rli, uint16 mflags,
+                             int *order_var);
   void sql_type(String &str) const;
   virtual uchar *pack(uchar *to, const uchar *from,
                       uint max_length, bool low_byte_first);
@@ -2081,7 +2086,8 @@
   /* Init for a tmp table field. To be extended if need be. */
   void init_for_tmp_table(enum_field_types sql_type_arg,
                           uint32 max_length, uint32 decimals,
-                          bool maybe_null, bool is_unsigned);
+                          bool maybe_null, bool is_unsigned,
+                          uint pack_length= ~0U);
 
   bool init(THD *thd, char *field_name, enum_field_types type, char *length,
             char *decimals, uint type_modifier, Item *default_value,

=== modified file 'Percona-Server/sql/log_event.cc'
--- Percona-Server/sql/log_event.cc	2012-02-22 07:32:22 +0000
+++ Percona-Server/sql/log_event.cc	2012-02-22 07:32:24 +0000
@@ -1588,37 +1588,14 @@
         /* a long CHAR() field: see #37426 */
         length= byte1 | (((byte0 & 0x30) ^ 0x30) << 4);
         type= byte0 | 0x30;
-        goto beg;
-      }
-
-      switch (byte0)
-      {
-        case MYSQL_TYPE_SET:
-        case MYSQL_TYPE_ENUM:
-        case MYSQL_TYPE_STRING:
-          type= byte0;
-          length= byte1;
-          break;
-
-        default:
-
-        {
-          char tmp[5];
-          my_snprintf(tmp, sizeof(tmp), "%04X", meta);
-          my_b_printf(file,
-                      "!! Don't know how to handle column type=%d meta=%d (%s)",
-                      type, meta, tmp);
-          return 0;
-        }
-      }
+      }
+      else
+        length= meta & 0xFF;
     }
     else
       length= meta;
   }
 
-
-beg:
-  
   switch (type) {
   case MYSQL_TYPE_LONG:
     {
@@ -1755,6 +1732,33 @@
       return 3;
     }
     
+  case MYSQL_TYPE_NEWDATE:
+    {
+      uint32 tmp= uint3korr(ptr);
+      int part;
+      char buf[11];
+      char *pos= &buf[10];
+
+      /* Copied from field.cc */
+      *pos--= 0;                                 // End NULL
+      part=   (int) (tmp & 31);
+      *pos--= (char) ('0'+part%10);
+      *pos--= (char) ('0'+part/10);
+      *pos--= ':';
+      part=   (int) (tmp >> 5 & 15);
+      *pos--= (char) ('0'+part%10);
+      *pos--= (char) ('0'+part/10);
+      *pos--= ':';
+      part=   (int) (tmp >> 9);
+      *pos--= (char) ('0'+part%10); part/=10;
+      *pos--= (char) ('0'+part%10); part/=10;
+      *pos--= (char) ('0'+part%10); part/=10;
+      *pos=   (char) ('0'+part);
+      my_b_printf(file , "'%s'", buf);
+      my_snprintf(typestr, typestr_length, "DATE");
+      return 3;
+    }
+
   case MYSQL_TYPE_DATE:
     {
       uint i32= uint3korr(ptr);
@@ -1773,7 +1777,8 @@
     }
   
   case MYSQL_TYPE_ENUM:
-    switch (length) { 
+    switch (meta & 0xFF)
+    {
     case 1:
       my_b_printf(file, "%d", (int) *ptr);
       my_snprintf(typestr, typestr_length, "ENUM(1 byte)");
@@ -1786,15 +1791,15 @@
         return 2;
       }
     default:
-      my_b_printf(file, "!! Unknown ENUM packlen=%d", length); 
+      my_b_printf(file, "!! Unknown ENUM packlen=%d", meta & 0xFF);
       return 0;
     }
     break;
     
   case MYSQL_TYPE_SET:
-    my_b_write_bit(file, ptr , length * 8);
-    my_snprintf(typestr, typestr_length, "SET(%d bytes)", length);
-    return length;
+    my_b_write_bit(file, ptr , (meta & 0xFF) * 8);
+    my_snprintf(typestr, typestr_length, "SET(%d bytes)", meta & 0xFF);
+    return meta & 0xFF;
   
   case MYSQL_TYPE_BLOB:
     switch (meta) {
@@ -7546,11 +7551,19 @@
     */
 
     {
+      DBUG_PRINT("debug", ("Checking compability of tables to lock - tables_to_lock: %p",
+                           rli->tables_to_lock));
       RPL_TABLE_LIST *ptr= rli->tables_to_lock;
       for ( ; ptr ; ptr= static_cast<RPL_TABLE_LIST*>(ptr->next_global))
       {
-        if (ptr->m_tabledef.compatible_with(rli, ptr->table))
+        TABLE *conv_table;
+        if (!ptr->m_tabledef.compatible_with(thd,
+                                             const_cast<Relay_log_info*>(rli),
+                                             ptr->table, &conv_table))
         {
+          DBUG_PRINT("debug", ("Table: %s.%s is not compatible with master",
+                               ptr->table->s->db.str,
+                               ptr->table->s->table_name.str));
           /*
             We should not honour --slave-skip-errors at this point as we are
             having severe errors which should not be skiped.
@@ -7561,12 +7574,17 @@
           const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
           DBUG_RETURN(ERR_BAD_TABLE_DEF);
         }
+        DBUG_PRINT("debug", ("Table: %s.%s is compatible with master"
+                             " - conv_table: %p",
+                             ptr->table->s->db.str,
+                             ptr->table->s->table_name.str, conv_table));
+        ptr->m_conv_table= conv_table;
       }
     }
 
     /*
-      ... and then we add all the tables to the table map and remove
-      them from tables to lock.
+      ... and then we add all the tables to the table map and but keep
+      them in the tables to lock list.
 
       We also invalidate the query cache for all the tables, since
       they will now be changed.
@@ -8201,7 +8219,10 @@
   DBUG_ENTER("Table_map_log_event::save_field_metadata");
   int index= 0;
   for (unsigned int i= 0 ; i < m_table->s->fields ; i++)
+  {
+    DBUG_PRINT("debug", ("field_type: %d", m_coltype[i]));
     index+= m_table->s->field[i]->save_field_metadata(&m_field_metadata[index]);
+  }
   DBUG_RETURN(index);
 }
 #endif /* !defined(MYSQL_CLIENT) */

=== modified file 'Percona-Server/sql/log_event_old.cc'
--- Percona-Server/sql/log_event_old.cc	2011-06-30 15:37:13 +0000
+++ Percona-Server/sql/log_event_old.cc	2012-02-22 07:32:24 +0000
@@ -121,14 +121,25 @@
       RPL_TABLE_LIST *ptr= rli->tables_to_lock;
       for ( ; ptr ; ptr= static_cast<RPL_TABLE_LIST*>(ptr->next_global))
       {
-        if (ptr->m_tabledef.compatible_with(rli, ptr->table))
+        TABLE *conv_table;
+        if (!ptr->m_tabledef.compatible_with(thd,
+                                             const_cast<Relay_log_info*>(rli),
+                                             ptr->table, &conv_table))
         {
+          DBUG_PRINT("debug", ("Table: %s.%s is not compatible with master",
+                               ptr->table->s->db.str,
+                               ptr->table->s->table_name.str));
           mysql_unlock_tables(ev_thd, ev_thd->lock);
           ev_thd->lock= 0;
           ev_thd->is_slave_error= 1;
           const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
           DBUG_RETURN(Old_rows_log_event::ERR_BAD_TABLE_DEF);
         }
+        DBUG_PRINT("debug", ("Table: %s.%s is compatible with master"
+                             " - conv_table: %p",
+                             ptr->table->s->db.str,
+                             ptr->table->s->table_name.str, conv_table));
+        ptr->m_conv_table= conv_table;
       }
     }
 
@@ -1615,7 +1626,10 @@
       RPL_TABLE_LIST *ptr= rli->tables_to_lock;
       for ( ; ptr ; ptr= static_cast<RPL_TABLE_LIST*>(ptr->next_global))
       {
-        if (ptr->m_tabledef.compatible_with(rli, ptr->table))
+        TABLE *conv_table;
+        if (ptr->m_tabledef.compatible_with(thd,
+                                            const_cast<Relay_log_info*>(rli),
+                                            ptr->table, &conv_table))
         {
           mysql_unlock_tables(thd, thd->lock);
           thd->lock= 0;
@@ -1623,12 +1637,14 @@
           const_cast<Relay_log_info*>(rli)->clear_tables_to_lock();
           DBUG_RETURN(ERR_BAD_TABLE_DEF);
         }
+        ptr->m_conv_table= conv_table;
       }
     }
 
     /*
-      ... and then we add all the tables to the table map and remove
-      them from tables to lock.
+      ... and then we add all the tables to the table map but keep
+      them in the tables to lock list.
+
 
       We also invalidate the query cache for all the tables, since
       they will now be changed.

=== modified file 'Percona-Server/sql/mysql_priv.h'
--- Percona-Server/sql/mysql_priv.h	2012-02-22 07:32:22 +0000
+++ Percona-Server/sql/mysql_priv.h	2012-02-22 07:32:24 +0000
@@ -2117,6 +2117,7 @@
 extern my_bool opt_safe_show_db, opt_local_infile, opt_myisam_use_mmap;
 extern my_bool opt_slave_compressed_protocol, use_temp_pool;
 extern ulong slave_exec_mode_options;
+extern ulong slave_type_conversions_options;
 extern my_bool opt_readonly, lower_case_file_system;
 extern my_bool opt_userstat_running, opt_thread_statistics;
 extern my_bool opt_optimizer_fix;

=== modified file 'Percona-Server/sql/mysqld.cc'
--- Percona-Server/sql/mysqld.cc	2012-02-22 07:32:22 +0000
+++ Percona-Server/sql/mysqld.cc	2012-02-22 07:32:24 +0000
@@ -599,6 +599,8 @@
 ulong slave_net_timeout, slave_trans_retries;
 ulong slave_exec_mode_options;
 static const char *slave_exec_mode_str= "STRICT";
+ulong slave_type_conversions_options;
+const char *slave_type_conversions_default= "";
 ulong thread_cache_size=0, thread_pool_size= 0;
 ulong binlog_cache_size=0;
 ulonglong  max_binlog_cache_size=0;
@@ -5910,6 +5912,7 @@
 #endif /* defined(ENABLED_DEBUG_SYNC) */
   OPT_OLD_MODE,
   OPT_SLAVE_EXEC_MODE,
+  OPT_SLAVE_TYPE_CONVERSIONS,
   OPT_GENERAL_LOG_FILE,
   OPT_SLOW_QUERY_LOG_FILE,
   OPT_USERSTAT_RUNNING,
@@ -6747,6 +6750,15 @@
    "not stop for operations that are idempotent. In STRICT mode, replication "
    "will stop on any unexpected difference between the master and the slave.",
    &slave_exec_mode_str, &slave_exec_mode_str, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
+  {"slave-type-conversions", OPT_SLAVE_TYPE_CONVERSIONS,
+   "Set of slave type conversions that are enabled. Legal values are:"
+   " ALL_LOSSY to enable lossy conversions and"
+   " ALL_NON_LOSSY to enable non-lossy conversions."
+   " If the variable is assigned the empty set, no conversions are"
+   " allowed and it is expected that the types match exactly.",
+   (uchar**) &slave_type_conversions_default,
+   (uchar**) &slave_type_conversions_default,
+   0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
 #endif
   {"slow-query-log", OPT_SLOW_LOG,
    "Enable/disable slow query log.", &opt_slow_log,
@@ -8152,6 +8164,11 @@
   slave_exec_mode_options= find_bit_type_or_exit(slave_exec_mode_str,
                                                  &slave_exec_mode_typelib,
                                                  NULL, &error);
+  /* Slave type conversions */
+  slave_type_conversions_options= 0;
+  slave_type_conversions_options=
+    find_bit_type_or_exit(slave_type_conversions_default, &slave_type_conversions_typelib,
+                          NULL, &error);
   /* Default mode string must not yield a error. */
   DBUG_ASSERT(!error);
   if (error)
@@ -8404,6 +8421,12 @@
     if (error)
       return 1;
     break;
+  case OPT_SLAVE_TYPE_CONVERSIONS:
+    slave_type_conversions_options= (uint)
+      find_bit_type_or_exit(argument, &slave_type_conversions_typelib, "", &error);
+    if (error)
+      return 1;
+    break;
 #endif
   case OPT_SAFEMALLOC_MEM_LIMIT:
 #if !defined(DBUG_OFF) && defined(SAFEMALLOC)

=== modified file 'Percona-Server/sql/rpl_record.cc'
--- Percona-Server/sql/rpl_record.cc	2011-06-30 15:37:13 +0000
+++ Percona-Server/sql/rpl_record.cc	2012-02-22 07:32:24 +0000
@@ -106,10 +106,10 @@
 #endif
         pack_ptr= field->pack(pack_ptr, field->ptr + offset,
                               field->max_data_length(), TRUE);
-        DBUG_PRINT("debug", ("field: %s; pack_ptr: 0x%lx;"
+        DBUG_PRINT("debug", ("field: %s; real_type: %d, pack_ptr: 0x%lx;"
                              " pack_ptr':0x%lx; bytes: %d",
-                             field->field_name, (ulong) old_pack_ptr,
-                             (ulong) pack_ptr,
+                             field->field_name, field->real_type(),
+                             (ulong) old_pack_ptr, (ulong) pack_ptr,
                              (int) (pack_ptr - old_pack_ptr)));
       }
 
@@ -152,13 +152,20 @@
    the various member functions of Field and subclasses expect to
    write.
 
-   The row is assumed to only consist of the fields for which the corresponding
-   bit in bitset @c cols is set; the other parts of the record are left alone.
+   The row is assumed to only consist of the fields for which the
+   corresponding bit in bitset @c cols is set; the other parts of the
+   record are left alone.
 
    At most @c colcnt columns are read: if the table is larger than
    that, the remaining fields are not filled in.
 
-   @param rli     Relay log info
+   @note The relay log information can be NULL, which means that no
+   checking or comparison with the source table is done, simply
+   because it is not used.  This feature is used by MySQL Backup to
+   unpack a row from from the backup image, but can be used for other
+   purposes as well.
+
+   @param rli     Relay log info, which can be NULL
    @param table   Table to unpack into
    @param colcnt  Number of columns to read from record
    @param row_data
@@ -172,11 +179,9 @@
 
    @retval 0 No error
 
-   @retval ER_NO_DEFAULT_FOR_FIELD
-   Returned if one of the fields existing on the slave but not on the
-   master does not have a default value (and isn't nullable)
-
- */
+   @retval HA_ERR_GENERIC
+   A generic, internal, error caused the unpacking to fail.
+*/
 #if !defined(MYSQL_CLIENT) && defined(HAVE_REPLICATION)
 int
 unpack_row(Relay_log_info const *rli,
@@ -186,6 +191,7 @@
 {
   DBUG_ENTER("unpack_row");
   DBUG_ASSERT(row_data);
+  DBUG_ASSERT(table);
   size_t const master_null_byte_count= (bitmap_bits_set(cols) + 7) / 8;
   int error= 0;
 
@@ -203,10 +209,37 @@
   // The "current" null bits
   unsigned int null_bits= *null_ptr++;
   uint i= 0;
-  table_def *tabledef= ((Relay_log_info*)rli)->get_tabledef(table);
+  table_def *tabledef= NULL;
+  TABLE *conv_table= NULL;
+  bool table_found= rli && rli->get_table_data(table, &tabledef, &conv_table);
+  DBUG_PRINT("debug", ("Table data: table_found: %d, tabldef: %p, conv_table: %p",
+                       table_found, tabledef, conv_table));
+  DBUG_ASSERT(table_found);
+
+  /*
+    If rli is NULL it means that there is no source table and that the
+    row shall just be unpacked without doing any checks. This feature
+    is used by MySQL Backup, but can be used for other purposes as
+    well.
+   */
+  if (rli && !table_found)
+    DBUG_RETURN(HA_ERR_GENERIC);
+
   for (field_ptr= begin_ptr ; field_ptr < end_ptr && *field_ptr ; ++field_ptr)
   {
-    Field *const f= *field_ptr;
+    /*
+      If there is a conversion table, we pick up the field pointer to
+      the conversion table.  If the conversion table or the field
+      pointer is NULL, no conversions are necessary.
+     */
+    Field *conv_field=
+      conv_table ? conv_table->field[field_ptr - begin_ptr] : NULL;
+    Field *const f=
+      conv_field ? conv_field : *field_ptr;
+    DBUG_PRINT("debug", ("Conversion %srequired for field '%s' (#%ld)",
+                         conv_field ? "" : "not ",
+                         (*field_ptr)->field_name, field_ptr - begin_ptr));
+    DBUG_ASSERT(f != NULL);
 
     /*
       No need to bother about columns that does not exist: they have
@@ -279,6 +312,39 @@
                              (int) (pack_ptr - old_pack_ptr)));
       }
 
+      /*
+        If conv_field is set, then we are doing a conversion. In this
+        case, we have unpacked the master data to the conversion
+        table, so we need to copy the value stored in the conversion
+        table into the final table and do the conversion at the same time.
+      */
+      if (conv_field)
+      {
+        Copy_field copy;
+#ifndef DBUG_OFF
+        char source_buf[MAX_FIELD_WIDTH];
+        char value_buf[MAX_FIELD_WIDTH];
+        String source_type(source_buf, sizeof(source_buf), system_charset_info);
+        String value_string(value_buf, sizeof(value_buf), system_charset_info);
+        conv_field->sql_type(source_type);
+        conv_field->val_str(&value_string);
+        DBUG_PRINT("debug", ("Copying field '%s' of type '%s' with value '%s'",
+                             (*field_ptr)->field_name,
+                             source_type.c_ptr_safe(), value_string.c_ptr_safe()));
+#endif
+        copy.set(*field_ptr, f, TRUE);
+        (*copy.do_copy)(&copy);
+#ifndef DBUG_OFF
+        char target_buf[MAX_FIELD_WIDTH];
+        String target_type(target_buf, sizeof(target_buf), system_charset_info);
+        (*field_ptr)->sql_type(target_type);
+        (*field_ptr)->val_str(&value_string);
+        DBUG_PRINT("debug", ("Value of field '%s' of type '%s' is now '%s'",
+                             (*field_ptr)->field_name,
+                             target_type.c_ptr_safe(), value_string.c_ptr_safe()));
+#endif
+      }
+
       null_mask <<= 1;
     }
     i++;

=== modified file 'Percona-Server/sql/rpl_rli.h'
--- Percona-Server/sql/rpl_rli.h	2012-02-22 07:32:22 +0000
+++ Percona-Server/sql/rpl_rli.h	2012-02-22 07:32:24 +0000
@@ -332,13 +332,21 @@
   uint tables_to_lock_count;        /* RBR: Count of tables to lock */
   table_mapping m_table_map;      /* RBR: Mapping table-id to table */
 
-  inline table_def *get_tabledef(TABLE *tbl)
+  bool get_table_data(TABLE *table_arg, table_def **tabledef_var, TABLE **conv_table_var) const
   {
-    table_def *td= 0;
-    for (TABLE_LIST *ptr= tables_to_lock; ptr && !td; ptr= ptr->next_global)
-      if (ptr->table == tbl)
-        td= &((RPL_TABLE_LIST *)ptr)->m_tabledef;
-    return (td);
+    DBUG_ASSERT(tabledef_var && conv_table_var);
+    for (TABLE_LIST *ptr= tables_to_lock ; ptr != NULL ; ptr= ptr->next_global)
+      if (ptr->table == table_arg)
+      {
+        *tabledef_var= &static_cast<RPL_TABLE_LIST*>(ptr)->m_tabledef;
+        *conv_table_var= static_cast<RPL_TABLE_LIST*>(ptr)->m_conv_table;
+        DBUG_PRINT("debug", ("Fetching table data for table %s.%s:"
+                             " tabledef: %p, conv_table: %p",
+                             table_arg->s->db.str, table_arg->s->table_name.str,
+                             *tabledef_var, *conv_table_var));
+        return true;
+      }
+    return false;
   }
 
   /*

=== modified file 'Percona-Server/sql/rpl_utility.cc'
--- Percona-Server/sql/rpl_utility.cc	2011-06-30 15:37:13 +0000
+++ Percona-Server/sql/rpl_utility.cc	2012-02-22 07:32:24 +0000
@@ -16,8 +16,177 @@
 */
 
 #include "rpl_utility.h"
+
+#ifndef MYSQL_CLIENT
 #include "rpl_rli.h"
 
+/**
+   Function to compare two size_t integers for their relative
+   order. Used below.
+ */
+int compare(size_t a, size_t b)
+{
+  if (a < b)
+    return -1;
+  if (b < a)
+    return 1;
+  return 0;
+}
+
+
+/**
+   Max value for an unsigned integer of 'bits' bits.
+
+   The somewhat contorted expression is to avoid overflow.
+ */
+uint32 uint_max(int bits)
+{
+  return (((1UL << (bits - 1)) - 1) << 1) | 1;
+}
+
+
+/**
+   Compute the maximum display length of a field.
+
+   @param sql_type Type of the field
+   @param metadata The metadata from the master for the field.
+   @return Maximum length of the field in bytes.
+ */
+static uint32
+max_display_length_for_field(enum_field_types sql_type, unsigned int metadata)
+{
+  DBUG_PRINT("debug", ("sql_type: %d, metadata: 0x%x", sql_type, metadata));
+  DBUG_ASSERT(metadata >> 16 == 0);
+
+  switch (sql_type) {
+  case MYSQL_TYPE_NEWDECIMAL:
+    return metadata >> 8;
+
+  case MYSQL_TYPE_FLOAT:
+    return 12;
+
+  case MYSQL_TYPE_DOUBLE:
+    return 22;
+
+  case MYSQL_TYPE_SET:
+  case MYSQL_TYPE_ENUM:
+      return metadata & 0x00ff;
+
+  case MYSQL_TYPE_STRING:
+  {
+    uchar type= metadata >> 8;
+    if (type == MYSQL_TYPE_SET || type == MYSQL_TYPE_ENUM)
+      return metadata & 0xff;
+    else
+      /* This is taken from Field_string::unpack. */
+      return (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff);
+  }
+
+  case MYSQL_TYPE_YEAR:
+  case MYSQL_TYPE_TINY:
+    return 4;
+
+  case MYSQL_TYPE_SHORT:
+    return 6;
+
+  case MYSQL_TYPE_INT24:
+    return 9;
+
+  case MYSQL_TYPE_LONG:
+    return 11;
+
+#ifdef HAVE_LONG_LONG
+  case MYSQL_TYPE_LONGLONG:
+    return 20;
+
+#endif
+  case MYSQL_TYPE_NULL:
+    return 0;
+
+  case MYSQL_TYPE_NEWDATE:
+    return 3;
+
+  case MYSQL_TYPE_DATE:
+  case MYSQL_TYPE_TIME:
+    return 3;
+
+  case MYSQL_TYPE_TIMESTAMP:
+    return 4;
+
+  case MYSQL_TYPE_DATETIME:
+    return 8;
+
+  case MYSQL_TYPE_BIT:
+    /*
+      Decode the size of the bit field from the master.
+    */
+    DBUG_ASSERT((metadata & 0xff) <= 7);
+    return 8 * (metadata >> 8U) + (metadata & 0x00ff);
+
+  case MYSQL_TYPE_VAR_STRING:
+  case MYSQL_TYPE_VARCHAR:
+    return metadata;
+
+    /*
+      The actual length for these types does not really matter since
+      they are used to calc_pack_length, which ignores the given
+      length for these types.
+
+      Since we want this to be accurate for other uses, we return the
+      maximum size in bytes of these BLOBs.
+    */
+
+  case MYSQL_TYPE_TINY_BLOB:
+    return uint_max(1 * 8);
+
+  case MYSQL_TYPE_MEDIUM_BLOB:
+    return uint_max(3 * 8);
+
+  case MYSQL_TYPE_BLOB:
+    /*
+      For the blob type, Field::real_type() lies and say that all
+      blobs are of type MYSQL_TYPE_BLOB. In that case, we have to look
+      at the length instead to decide what the max display size is.
+     */
+    return uint_max(metadata * 8);
+
+  case MYSQL_TYPE_LONG_BLOB:
+  case MYSQL_TYPE_GEOMETRY:
+    return uint_max(4 * 8);
+
+  default:
+    return ~(uint32) 0;
+  }
+}
+
+
+/*
+  Compare the pack lengths of a source field (on the master) and a
+  target field (on the slave).
+
+  @param field    Target field.
+  @param type     Source field type.
+  @param metadata Source field metadata.
+
+  @retval -1 The length of the source field is smaller than the target field.
+  @retval  0 The length of the source and target fields are the same.
+  @retval  1 The length of the source field is greater than the target field.
+ */
+int compare_lengths(Field *field, enum_field_types source_type, uint16 metadata)
+{
+  DBUG_ENTER("compare_lengths");
+  size_t const source_length=
+    max_display_length_for_field(source_type, metadata);
+  size_t const target_length= field->max_display_length();
+  DBUG_PRINT("debug", ("source_length: %lu, source_type: %u,"
+                       " target_length: %lu, target_type: %u",
+                       (unsigned long) source_length, source_type,
+                       (unsigned long) target_length, field->real_type()));
+  int result= compare(source_length, target_length);
+  DBUG_PRINT("result", ("%d", result));
+  DBUG_RETURN(result);
+}
+
 /*********************************************************************
  *                   table_def member definitions                    *
  *********************************************************************/
@@ -171,58 +340,714 @@
   return length;
 }
 
-/*
-  Is the definition compatible with a table?
-
-*/
-int
-table_def::compatible_with(Relay_log_info const *rli_arg, TABLE *table)
+/**
+ */
+void show_sql_type(enum_field_types type, uint16 metadata, String *str)
+{
+  DBUG_ENTER("show_sql_type");
+  DBUG_PRINT("enter", ("type: %d, metadata: 0x%x", type, metadata));
+
+  switch (type)
+  {
+  case MYSQL_TYPE_TINY:
+    str->set_ascii(STRING_WITH_LEN("tinyint"));
+    break;
+
+  case MYSQL_TYPE_SHORT:
+    str->set_ascii(STRING_WITH_LEN("smallint"));
+    break;
+
+  case MYSQL_TYPE_LONG:
+    str->set_ascii(STRING_WITH_LEN("int"));
+    break;
+
+  case MYSQL_TYPE_FLOAT:
+    str->set_ascii(STRING_WITH_LEN("float"));
+    break;
+
+  case MYSQL_TYPE_DOUBLE:
+    str->set_ascii(STRING_WITH_LEN("double"));
+    break;
+
+  case MYSQL_TYPE_NULL:
+    str->set_ascii(STRING_WITH_LEN("null"));
+    break;
+
+  case MYSQL_TYPE_TIMESTAMP:
+    str->set_ascii(STRING_WITH_LEN("timestamp"));
+    break;
+
+  case MYSQL_TYPE_LONGLONG:
+    str->set_ascii(STRING_WITH_LEN("bigint"));
+    break;
+
+  case MYSQL_TYPE_INT24:
+    str->set_ascii(STRING_WITH_LEN("mediumint"));
+    break;
+
+  case MYSQL_TYPE_NEWDATE:
+  case MYSQL_TYPE_DATE:
+    str->set_ascii(STRING_WITH_LEN("date"));
+    break;
+
+  case MYSQL_TYPE_TIME:
+    str->set_ascii(STRING_WITH_LEN("time"));
+    break;
+
+  case MYSQL_TYPE_DATETIME:
+    str->set_ascii(STRING_WITH_LEN("datetime"));
+    break;
+
+  case MYSQL_TYPE_YEAR:
+    str->set_ascii(STRING_WITH_LEN("year"));
+    break;
+
+  case MYSQL_TYPE_VAR_STRING:
+  case MYSQL_TYPE_VARCHAR:
+    {
+      CHARSET_INFO *cs= str->charset();
+      uint32 length=
+        cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
+                           "varchar(%u)", metadata);
+      str->length(length);
+    }
+    break;
+
+  case MYSQL_TYPE_BIT:
+    {
+      CHARSET_INFO *cs= str->charset();
+      int bit_length= 8 * (metadata >> 8) + (metadata & 0xFF);
+      uint32 length=
+        cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
+                           "bit(%d)", bit_length);
+      str->length(length);
+    }
+    break;
+
+  case MYSQL_TYPE_DECIMAL:
+    {
+      CHARSET_INFO *cs= str->charset();
+      uint32 length=
+        cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
+                           "decimal(%d,?)", metadata);
+      str->length(length);
+    }
+    break;
+
+  case MYSQL_TYPE_NEWDECIMAL:
+    {
+      CHARSET_INFO *cs= str->charset();
+      uint32 length=
+        cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
+                           "decimal(%d,%d)", metadata >> 8, metadata & 0xff);
+      str->length(length);
+    }
+    break;
+
+  case MYSQL_TYPE_ENUM:
+    str->set_ascii(STRING_WITH_LEN("enum"));
+    break;
+
+  case MYSQL_TYPE_SET:
+    str->set_ascii(STRING_WITH_LEN("set"));
+    break;
+
+  case MYSQL_TYPE_BLOB:
+    /*
+      Field::real_type() lies regarding the actual type of a BLOB, so
+      it is necessary to check the pack length to figure out what kind
+      of blob it really is.
+     */
+    switch (get_blob_type_from_length(metadata))
+    {
+    case MYSQL_TYPE_TINY_BLOB:
+      str->set_ascii(STRING_WITH_LEN("tinyblob"));
+      break;
+
+    case MYSQL_TYPE_MEDIUM_BLOB:
+      str->set_ascii(STRING_WITH_LEN("mediumblob"));
+      break;
+
+    case MYSQL_TYPE_LONG_BLOB:
+      str->set_ascii(STRING_WITH_LEN("longblob"));
+      break;
+
+    case MYSQL_TYPE_BLOB:
+      str->set_ascii(STRING_WITH_LEN("blob"));
+      break;
+
+    default:
+      DBUG_ASSERT(0);
+      break;
+    }
+    break;
+
+  case MYSQL_TYPE_STRING:
+    {
+      /*
+        This is taken from Field_string::unpack.
+      */
+      CHARSET_INFO *cs= str->charset();
+      uint bytes= (((metadata >> 4) & 0x300) ^ 0x300) + (metadata & 0x00ff);
+      uint32 length=
+        cs->cset->snprintf(cs, (char*) str->ptr(), str->alloced_length(),
+                           "char(%d)", bytes / cs->mbmaxlen);
+      str->length(length);
+    }
+    break;
+
+  case MYSQL_TYPE_GEOMETRY:
+    str->set_ascii(STRING_WITH_LEN("geometry"));
+    break;
+
+  default:
+    str->set_ascii(STRING_WITH_LEN("<unknown type>"));
+  }
+  DBUG_VOID_RETURN;
+}
+
+
+/**
+   Check the order variable and print errors if the order is not
+   acceptable according to the current settings.
+
+   @param order  The computed order of the conversion needed.
+   @param rli    The relay log info data structure: for error reporting.
+*/
+bool is_conversion_ok(int order, Relay_log_info *rli)
+{
+  DBUG_ENTER("is_conversion_ok");
+  bool allow_non_lossy= (slave_type_conversions_options & SLAVE_TYPE_CONVERSIONS_ALL_NON_LOSSY);
+  bool allow_lossy= (slave_type_conversions_options & SLAVE_TYPE_CONVERSIONS_ALL_LOSSY);
+
+  DBUG_PRINT("enter", ("order: %d, flags:%s%s", order,
+                       allow_non_lossy ? " ALL_NON_LOSSY" : "",
+                       allow_lossy ? " ALL_LOSSY" : ""));
+  if (order < 0 && !allow_non_lossy)
+  {
+    /* !!! Add error message saying that non-lossy conversions need to be allowed. */
+    DBUG_RETURN(false);
+  }
+
+  if (order > 0 && !allow_lossy)
+  {
+    /* !!! Add error message saying that lossy conversions need to be allowed. */
+    DBUG_RETURN(false);
+  }
+
+  DBUG_RETURN(true);
+}
+
+
+/**
+   Can a type potentially be converted to another type?
+
+   This function check if the types are convertible and what
+   conversion is required.
+
+   If conversion is not possible, and error is printed.
+
+   If conversion is possible:
+
+   - *order will be set to -1 if source type is smaller than target
+     type and a non-lossy conversion can be required. This includes
+     the case where the field types are different but types could
+     actually be converted in either direction.
+
+   - *order will be set to 0 if no conversion is required.
+
+   - *order will be set to 1 if the source type is strictly larger
+      than the target type and that conversion is potentially lossy.
+
+   @param[in] field    Target field
+   @param[in] type     Source field type
+   @param[in] metadata Source field metadata
+   @param[in] rli      Relay log info (for error reporting)
+   @param[in] mflags   Flags from the table map event
+   @param[out] order   Order between source field and target field
+
+   @return @c true if conversion is possible according to the current
+   settings, @c false if conversion is not possible according to the
+   current setting.
+ */
+static bool
+can_convert_field_to(Field *field,
+                     enum_field_types source_type, uint16 metadata,
+                     Relay_log_info *rli, uint16 mflags,
+                     int *order_var)
+{
+  DBUG_ENTER("can_convert_field_to");
+#ifndef DBUG_OFF
+  char field_type_buf[MAX_FIELD_WIDTH];
+  String field_type(field_type_buf, sizeof(field_type_buf), field->charset());
+  field->sql_type(field_type);
+  DBUG_PRINT("enter", ("field_type: %s, target_type: %d, source_type: %d, source_metadata: 0x%x",
+                       field_type.c_ptr_safe(), field->real_type(), source_type, metadata));
+#endif
+  /*
+    If the real type is the same, we need to check the metadata to
+    decide if conversions are allowed.
+   */
+  if (field->real_type() == source_type)
+  {
+    if (metadata == 0) // Metadata can only be zero if no metadata was provided
+    {
+      /*
+        If there is no metadata, we either have an old event where no
+        metadata were supplied, or a type that does not require any
+        metadata. In either case, conversion can be done but no
+        conversion table is necessary.
+       */
+      DBUG_PRINT("debug", ("Base types are identical, but there is no metadata"));
+      *order_var= 0;
+      DBUG_RETURN(true);
+    }
+
+    DBUG_PRINT("debug", ("Base types are identical, doing field size comparison"));
+    if (field->compatible_field_size(metadata, rli, mflags, order_var))
+      DBUG_RETURN(is_conversion_ok(*order_var, rli));
+    else
+      DBUG_RETURN(false);
+  }
+  else if (!slave_type_conversions_options)
+    DBUG_RETURN(false);
+
+  /*
+    Here, from and to will always be different. Since the types are
+    different, we cannot use the compatible_field_size() function, but
+    have to rely on hard-coded max-sizes for fields.
+  */
+
+  DBUG_PRINT("debug", ("Base types are different, checking conversion"));
+  switch (source_type)                      // Source type (on master)
+  {
+  case MYSQL_TYPE_DECIMAL:
+  case MYSQL_TYPE_NEWDECIMAL:
+  case MYSQL_TYPE_FLOAT:
+  case MYSQL_TYPE_DOUBLE:
+    switch (field->real_type())
+    {
+    case MYSQL_TYPE_NEWDECIMAL:
+      /*
+        Then the other type is either FLOAT, DOUBLE, or old style
+        DECIMAL, so we require lossy conversion.
+      */
+      *order_var= 1;
+      DBUG_RETURN(is_conversion_ok(*order_var, rli));
+      
+    case MYSQL_TYPE_DECIMAL:
+    case MYSQL_TYPE_FLOAT:
+    case MYSQL_TYPE_DOUBLE:
+    {
+      if (source_type == MYSQL_TYPE_NEWDECIMAL ||
+          source_type == MYSQL_TYPE_DECIMAL)
+        *order_var= 1;                            // Always require lossy conversions
+      else
+        *order_var= compare_lengths(field, source_type, metadata);
+      DBUG_ASSERT(*order_var != 0);
+      DBUG_RETURN(is_conversion_ok(*order_var, rli));
+    }
+
+    default:
+      DBUG_RETURN(false);
+    }
+    break;
+
+  /*
+    The length comparison check will do the correct job of comparing
+    the field lengths (in bytes) of two integer types.
+  */
+  case MYSQL_TYPE_TINY:
+  case MYSQL_TYPE_SHORT:
+  case MYSQL_TYPE_INT24:
+  case MYSQL_TYPE_LONG:
+  case MYSQL_TYPE_LONGLONG:
+    switch (field->real_type())
+    {
+    case MYSQL_TYPE_TINY:
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_INT24:
+    case MYSQL_TYPE_LONG:
+    case MYSQL_TYPE_LONGLONG:
+      *order_var= compare_lengths(field, source_type, metadata);
+      DBUG_ASSERT(*order_var != 0);
+      DBUG_RETURN(is_conversion_ok(*order_var, rli));
+
+    default:
+      DBUG_RETURN(false);
+    }
+    break;
+
+  /*
+    Since source and target type is different, and it is not possible
+    to convert bit types to anything else, this will return false.
+   */
+  case MYSQL_TYPE_BIT:
+    DBUG_RETURN(false);
+
+  /*
+    If all conversions are disabled, it is not allowed to convert
+    between these types. Since the TEXT vs. BINARY is distinguished by
+    the charset, and the charset is not replicated, we cannot
+    currently distinguish between , e.g., TEXT and BLOB.
+   */
+  case MYSQL_TYPE_TINY_BLOB:
+  case MYSQL_TYPE_MEDIUM_BLOB:
+  case MYSQL_TYPE_LONG_BLOB:
+  case MYSQL_TYPE_BLOB:
+  case MYSQL_TYPE_STRING:
+  case MYSQL_TYPE_VAR_STRING:
+  case MYSQL_TYPE_VARCHAR:
+    switch (field->real_type())
+    {
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_STRING:
+    case MYSQL_TYPE_VAR_STRING:
+    case MYSQL_TYPE_VARCHAR:
+      *order_var= compare_lengths(field, source_type, metadata);
+      /*
+        Here we know that the types are different, so if the order
+        gives that they do not require any conversion, we still need
+        to have non-lossy conversion enabled to allow conversion
+        between different (string) types of the same length.
+       */
+      if (*order_var == 0)
+        *order_var= -1;
+      DBUG_RETURN(is_conversion_ok(*order_var, rli));
+
+    default:
+      DBUG_RETURN(false);
+    }
+    break;
+
+  case MYSQL_TYPE_GEOMETRY:
+  case MYSQL_TYPE_TIMESTAMP:
+  case MYSQL_TYPE_DATE:
+  case MYSQL_TYPE_TIME:
+  case MYSQL_TYPE_DATETIME:
+  case MYSQL_TYPE_YEAR:
+  case MYSQL_TYPE_NEWDATE:
+  case MYSQL_TYPE_NULL:
+  case MYSQL_TYPE_ENUM:
+  case MYSQL_TYPE_SET:
+    DBUG_RETURN(false);
+  }
+  DBUG_RETURN(false);                                 // To keep GCC happy
+}
+
+
+/**
+  Is the definition compatible with a table?
+
+  This function will compare the master table with an existing table
+  on the slave and see if they are compatible with respect to the
+  current settings of @c SLAVE_TYPE_CONVERSIONS.
+
+  If the tables are compatible and conversions are required, @c
+  *tmp_table_var will be set to a virtual temporary table with field
+  pointers for the fields that require conversions.  This allow simple
+  checking of whether a conversion are to be applied or not.
+
+  If tables are compatible, but no conversions are necessary, @c
+  *tmp_table_var will be set to NULL.
+
+  @param rli_arg[in]
+  Relay log info, for error reporting.
+
+  @param table[in]
+  Table to compare with
+
+  @param tmp_table_var[out]
+  Virtual temporary table for performing conversions, if necessary.
+
+  @retval true Master table is compatible with slave table.
+  @retval false Master table is not compatible with slave table.
+  Is the definition compatible with a table?
+
+*/
+bool
+table_def::compatible_with(THD *thd, Relay_log_info *rli,
+                           TABLE *table, TABLE **conv_table_var)
   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;
+  TABLE *tmp_table= NULL;
 
   for (uint col= 0 ; col < cols_to_check ; ++col)
   {
     Field *const field= table->field[col];
-    if (field->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,
-                  field->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 &&
-        !field->compatible_field_size(field_metadata(col), rli_arg, m_flags))
-    {
-      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,
-                  field->pack_length_from_metadata(m_field_metadata[col]),
-                  tsh->db.str, tsh->table_name.str,
-                  field->row_pack_length());
-      rli->report(ERROR_LEVEL, ER_BINLOG_ROW_WRONG_TABLE_DEF,
-                  ER(ER_BINLOG_ROW_WRONG_TABLE_DEF), buf);
-    }
-  }
-
-  return error;
+    int order;
+    if (can_convert_field_to(field, type(col), field_metadata(col), rli, m_flags, &order))
+    {
+      DBUG_PRINT("debug", ("Checking column %d -"
+                           " field '%s' can be converted - order: %d",
+                           col, field->field_name, order));
+      DBUG_ASSERT(order >= -1 && order <= 1);
+
+      /*
+        If order is not 0, a conversion is required, so we need to set
+        up the conversion table.
+       */
+      if (order != 0 && tmp_table == NULL)
+      {
+        /*
+          This will create the full table with all fields. This is
+          necessary to ge the correct field lengths for the record.
+        */
+        tmp_table= create_conversion_table(thd, rli, table);
+        if (tmp_table == NULL)
+            return false;
+        /*
+          Clear all fields up to, but not including, this column.
+        */
+        for (unsigned int i= 0; i < col; ++i)
+          tmp_table->field[i]= NULL;
+      }
+
+      if (order == 0 && tmp_table != NULL)
+        tmp_table->field[col]= NULL;
+    }
+    else
+    {
+      DBUG_PRINT("debug", ("Checking column %d -"
+                           " field '%s' can not be converted",
+                           col, field->field_name));
+      DBUG_ASSERT(col < size() && col < table->s->fields);
+      DBUG_ASSERT(table->s->db.str && table->s->table_name.str);
+      const char *db_name= table->s->db.str;
+      const char *tbl_name= table->s->table_name.str;
+      char source_buf[MAX_FIELD_WIDTH];
+      char target_buf[MAX_FIELD_WIDTH];
+      String source_type(source_buf, sizeof(source_buf), field->charset());
+      String target_type(target_buf, sizeof(target_buf), field->charset());
+      show_sql_type(type(col), field_metadata(col), &source_type);
+      field->sql_type(target_type);
+      rli->report(ERROR_LEVEL, ER_SLAVE_CONVERSION_FAILED,
+                  ER(ER_SLAVE_CONVERSION_FAILED),
+                  col, db_name, tbl_name,
+                  source_type.c_ptr_safe(), target_type.c_ptr_safe());
+      return false;
+    }
+  }
+
+#ifndef DBUG_OFF
+  if (tmp_table)
+  {
+    for (unsigned int col= 0; col < tmp_table->s->fields; ++col)
+      if (tmp_table->field[col])
+      {
+        char source_buf[MAX_FIELD_WIDTH];
+        char target_buf[MAX_FIELD_WIDTH];
+        String source_type(source_buf, sizeof(source_buf), table->field[col]->charset());
+        String target_type(target_buf, sizeof(target_buf), table->field[col]->charset());
+        tmp_table->field[col]->sql_type(source_type);
+        table->field[col]->sql_type(target_type);
+        DBUG_PRINT("debug", ("Field %s - conversion required."
+                             " Source type: '%s', Target type: '%s'",
+                             tmp_table->field[col]->field_name,
+                             source_type.c_ptr_safe(), target_type.c_ptr_safe()));
+      }
+  }
+#endif
+
+  *conv_table_var= tmp_table;
+  return true;
+}
+
+/**
+  Create a conversion table.
+
+  If the function is unable to create the conversion table, an error
+  will be printed and NULL will be returned.
+
+  @return Pointer to conversion table, or NULL if unable to create
+  conversion table.
+*/
+TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli,
+                                          TABLE *target_table) const
+{
+  DBUG_ENTER("table_def::create_conversion_table");
+
+  List<Create_field> field_list;
+
+  uint const cols_to_check= min(target_table->s->fields, size());
+  for (uint col= 0 ; col < cols_to_check; ++col)
+  {
+    Create_field *field_def=
+      (Create_field*) alloc_root(thd->mem_root, sizeof(Create_field));
+    if (field_list.push_back(field_def))
+      DBUG_RETURN(NULL);
+
+    uint decimals= 0;
+    TYPELIB* interval= NULL;
+    uint pack_length= 0;
+    uint32 max_length=
+      max_display_length_for_field(type(col), field_metadata(col));
+
+    switch(type(col))
+    {
+      int precision;
+    case MYSQL_TYPE_ENUM:
+    case MYSQL_TYPE_SET:
+      interval= static_cast<Field_enum*>(target_table->field[col])->typelib;
+      pack_length= field_metadata(col) & 0x00ff;
+      break;
+
+    case MYSQL_TYPE_NEWDECIMAL:
+      /*
+        The display length of a DECIMAL type is not the same as the
+        length that should be supplied to make_field, so we correct
+        the length here.
+       */
+      precision= field_metadata(col) >> 8;
+      decimals= field_metadata(col) & 0x00ff;
+      max_length=
+        my_decimal_precision_to_length(precision, decimals, FALSE);
+      break;
+
+    case MYSQL_TYPE_DECIMAL:
+      precision= field_metadata(col);
+      decimals= static_cast<Field_num*>(target_table->field[col])->dec;
+      max_length= field_metadata(col);
+      break;
+
+    case MYSQL_TYPE_TINY_BLOB:
+    case MYSQL_TYPE_MEDIUM_BLOB:
+    case MYSQL_TYPE_LONG_BLOB:
+    case MYSQL_TYPE_BLOB:
+    case MYSQL_TYPE_GEOMETRY:
+      pack_length= field_metadata(col) & 0x00ff;
+      break;
+
+    default:
+      break;
+    }
+
+    DBUG_PRINT("debug", ("sql_type: %d, target_field: '%s', max_length: %d, decimals: %d,"
+                         " maybe_null: %d, unsigned_flag: %d, pack_length: %u",
+                         type(col), target_table->field[col]->field_name,
+                         max_length, decimals, TRUE, FALSE, pack_length));
+    field_def->init_for_tmp_table(type(col),
+                                  max_length,
+                                  decimals,
+                                  TRUE,         // maybe_null
+                                  FALSE,        // unsigned_flag
+                                  pack_length);
+    field_def->charset= target_table->field[col]->charset();
+    field_def->interval= interval;
+  }
+
+  TABLE *conv_table= create_virtual_tmp_table(thd, field_list);
+  if (conv_table == NULL)
+    rli->report(ERROR_LEVEL, ER_SLAVE_CANT_CREATE_CONVERSION,
+                ER(ER_SLAVE_CANT_CREATE_CONVERSION),
+                target_table->s->db.str,
+                target_table->s->table_name.str);
+  DBUG_RETURN(conv_table);
+}
+
+#endif /* MYSQL_CLIENT */
+
+table_def::table_def(unsigned char *types, ulong size,
+                     uchar *field_metadata, int metadata_size,
+                     uchar *null_bitmap, uint16 flags)
+  : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
+    m_field_metadata(0), m_null_bits(0), m_flags(flags),
+    m_memory(NULL)
+{
+  m_memory= (uchar *)my_multi_malloc(MYF(MY_WME), &m_type, size,
+                                     &m_field_metadata, size * sizeof(uint16),
+                                     &m_null_bits, (size + 7) / 8, NULL);
+
+  bzero(m_field_metadata, size * sizeof(uint16));
+
+  if (m_type)
+    memcpy(m_type, types, size);
+  else
+    m_size= 0;
+  /*
+    Extract the data from the table map into the field metadata array
+    iff there is field metadata. The variable metadata_size will be
+    0 if we are replicating from an older version server since no field
+    metadata was written to the table map. This can also happen if 
+    there were no fields in the master that needed extra metadata.
+  */
+  if (m_size && metadata_size)
+  { 
+    int index= 0;
+    for (unsigned int i= 0; i < m_size; i++)
+    {
+      switch (m_type[i]) {
+      case MYSQL_TYPE_TINY_BLOB:
+      case MYSQL_TYPE_BLOB:
+      case MYSQL_TYPE_MEDIUM_BLOB:
+      case MYSQL_TYPE_LONG_BLOB:
+      case MYSQL_TYPE_DOUBLE:
+      case MYSQL_TYPE_FLOAT:
+      case MYSQL_TYPE_GEOMETRY:
+      {
+        /*
+          These types store a single byte.
+        */
+        m_field_metadata[i]= field_metadata[index];
+        index++;
+        break;
+      }
+      case MYSQL_TYPE_SET:
+      case MYSQL_TYPE_ENUM:
+      case MYSQL_TYPE_STRING:
+      {
+        uint16 x= field_metadata[index++] << 8U; // real_type
+        x+= field_metadata[index++];            // pack or field length
+        m_field_metadata[i]= x;
+        break;
+      }
+      case MYSQL_TYPE_BIT:
+      {
+        uint16 x= field_metadata[index++];
+        x= x + (field_metadata[index++] << 8U);
+        m_field_metadata[i]= x;
+        break;
+      }
+      case MYSQL_TYPE_VARCHAR:
+      {
+        /*
+          These types store two bytes.
+        */
+        char *ptr= (char *)&field_metadata[index];
+        m_field_metadata[i]= uint2korr(ptr);
+        index= index + 2;
+        break;
+      }
+      case MYSQL_TYPE_NEWDECIMAL:
+      {
+        uint16 x= field_metadata[index++] << 8U; // precision
+        x+= field_metadata[index++];            // decimals
+        m_field_metadata[i]= x;
+        break;
+      }
+      default:
+        m_field_metadata[i]= 0;
+        break;
+      }
+    }
+  }
+  if (m_size && null_bitmap)
+    memcpy(m_null_bits, null_bitmap, (m_size + 7) / 8);
+}
+
+
+table_def::~table_def()
+{
+  my_free(m_memory, MYF(0));
+#ifndef DBUG_OFF
+  m_type= 0;
+  m_size= 0;
+#endif
 }

=== modified file 'Percona-Server/sql/rpl_utility.h'
--- Percona-Server/sql/rpl_utility.h	2011-06-30 15:37:13 +0000
+++ Percona-Server/sql/rpl_utility.h	2012-02-22 07:32:24 +0000
@@ -23,6 +23,7 @@
 #endif
 
 #include "mysql_priv.h"
+#include "mysql_com.h"
 
 class Relay_log_info;
 
@@ -40,116 +41,18 @@
 {
 public:
   /**
-    Convenience declaration of the type of the field type data in a
-    table map event.
-  */
-  typedef unsigned char field_type;
-
-  /**
     Constructor.
 
-    @param types Array of types
+    @param types Array of types, each stored as a byte
     @param size  Number of elements in array 'types'
     @param field_metadata Array of extra information about fields
     @param metadata_size Size of the field_metadata array
     @param null_bitmap The bitmap of fields that can be null
    */
-  table_def(field_type *types, ulong size, uchar *field_metadata, 
-      int metadata_size, uchar *null_bitmap, uint16 flags)
-    : m_size(size), m_type(0), m_field_metadata_size(metadata_size),
-    m_field_metadata(0), m_null_bits(0), m_flags(flags), m_memory(NULL)
-  {
-    m_memory= (uchar *)my_multi_malloc(MYF(MY_WME),
-                                       &m_type, size,
-                                       &m_field_metadata,
-                                       size * sizeof(uint16),
-                                       &m_null_bits, (size + 7) / 8,
-                                       NULL);
-
-    bzero(m_field_metadata, size * sizeof(uint16));
-
-    if (m_type)
-      memcpy(m_type, types, size);
-    else
-      m_size= 0;
-    /*