From 2e941fe9fce7f1667993916ff3f238a283286d3f Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Thu, 25 Jun 2015 23:18:48 +0300
Subject: Fixed crashing bug when using ONLY_FULL_GROUP_BY in a stored
 procedure/trigger that is repeatedly executed. This is MDEV-7601, including
 it's sub tasks MDEV-7594, MDEV-7555, MDEV-7590, MDEV-7581, MDEV-7589

The problem was that select_lex->non_agg_fields was not properly reset for re-execution and this caused an overwrite of a random memory position.
The fix was move non_agg_fields from select_lext to JOIN, which is properly reset.
---
 mysql-test/r/sp-group.result | 156 ++++++++++++++++++++++++++++++++++++
 mysql-test/t/sp-group.test   | 187 +++++++++++++++++++++++++++++++++++++++++++
 sql/item.cc                  |   7 +-
 sql/item.h                   |   2 +-
 sql/sql_lex.cc               |   2 +-
 sql/sql_lex.h                |   2 -
 sql/sql_select.cc            |   2 +-
 sql/sql_select.h             |   4 +
 sql/sql_union.cc             |   3 +-
 sql/table.cc                 |   2 +-
 10 files changed, 357 insertions(+), 10 deletions(-)
 create mode 100644 mysql-test/r/sp-group.result
 create mode 100644 mysql-test/t/sp-group.test

diff --git a/mysql-test/r/sp-group.result b/mysql-test/r/sp-group.result
new file mode 100644
index 00000000000..9744bbee6b6
--- /dev/null
+++ b/mysql-test/r/sp-group.result
@@ -0,0 +1,156 @@
+drop table if exists t1;
+Warnings:
+Note	1051	Unknown table 't1'
+drop view if exists view_t1;
+Warnings:
+Note	1051	Unknown table 'test.view_t1'
+SET sql_mode=ONLY_FULL_GROUP_BY;
+CREATE TABLE t1 (
+pk INT, 
+f0 INT, f1 INT, f2 INT, f3 INT, f4 INT, 
+f5 INT, f6 INT, f7 INT, f8 INT, f9 INT, 
+PRIMARY KEY (pk)
+);
+CREATE VIEW view_t1 AS SELECT * FROM t1;
+CREATE PROCEDURE s1() 
+SELECT * FROM (
+INFORMATION_SCHEMA.`INNODB_BUFFER_PAGE_LRU` AS table1
+LEFT JOIN test.view_t1 AS table2
+ON ( table2.`f6` = table1.FREE_PAGE_CLOCK) 
+) 
+ORDER BY table1.NUMBER_RECORDS
+LIMIT 0
+;
+CALL s1;
+POOL_ID	LRU_POSITION	SPACE	PAGE_NUMBER	PAGE_TYPE	FLUSH_TYPE	FIX_COUNT	IS_HASHED	NEWEST_MODIFICATION	OLDEST_MODIFICATION	ACCESS_TIME	TABLE_NAME	INDEX_NAME	NUMBER_RECORDS	DATA_SIZE	COMPRESSED_SIZE	COMPRESSED	IO_FIX	IS_OLD	FREE_PAGE_CLOCK	pk	f0	f1	f2	f3	f4	f5	f6	f7	f8	f9
+CALL s1;
+POOL_ID	LRU_POSITION	SPACE	PAGE_NUMBER	PAGE_TYPE	FLUSH_TYPE	FIX_COUNT	IS_HASHED	NEWEST_MODIFICATION	OLDEST_MODIFICATION	ACCESS_TIME	TABLE_NAME	INDEX_NAME	NUMBER_RECORDS	DATA_SIZE	COMPRESSED_SIZE	COMPRESSED	IO_FIX	IS_OLD	FREE_PAGE_CLOCK	pk	f0	f1	f2	f3	f4	f5	f6	f7	f8	f9
+drop table t1;
+drop view view_t1;
+drop procedure s1;
+CREATE TABLE A (
+pk INTEGER AUTO_INCREMENT,
+col_int_key INTEGER,
+col_varchar_key VARCHAR(1),
+PRIMARY KEY (pk)
+) ENGINE=MyISAM;
+CREATE VIEW view_A AS SELECT * FROM A;
+CREATE TABLE C (
+pk INTEGER AUTO_INCREMENT,
+col_int_nokey INTEGER,
+col_int_key INTEGER,
+col_date_key DATE,
+col_date_nokey DATE,
+col_time_key TIME,
+col_time_nokey TIME,
+col_datetime_key DATETIME,
+col_datetime_nokey DATETIME,
+col_varchar_key VARCHAR(1),
+col_varchar_nokey VARCHAR(1),
+PRIMARY KEY (pk)
+) ENGINE=MyISAM;
+CREATE VIEW view_C AS SELECT * FROM C;
+CREATE TABLE AA (
+pk INTEGER AUTO_INCREMENT,
+col_int_nokey INTEGER,
+col_int_key INTEGER,
+col_date_key DATE,
+col_date_nokey DATE,
+col_time_key TIME,
+col_time_nokey TIME,
+col_datetime_key DATETIME,
+col_datetime_nokey DATETIME,
+col_varchar_key VARCHAR(1),
+col_varchar_nokey VARCHAR(1),
+PRIMARY KEY (pk),
+KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_AA AS SELECT * FROM AA;
+CREATE TABLE BB (
+pk INTEGER AUTO_INCREMENT,
+col_int_key INTEGER,
+col_varchar_key VARCHAR(1),
+col_varchar_nokey VARCHAR(1),
+PRIMARY KEY (pk),
+KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_BB AS SELECT * FROM BB;
+CREATE TABLE DD (
+pk INTEGER AUTO_INCREMENT,
+col_int_key INTEGER,
+col_date_key DATE,
+col_time_key TIME,
+col_datetime_key DATETIME,
+col_varchar_key VARCHAR(1),
+PRIMARY KEY (pk),
+KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_DD AS SELECT * FROM DD;
+CREATE TRIGGER k BEFORE INSERT ON `DD` FOR EACH ROW INSERT INTO `view_BB` SELECT * FROM `view_A` LIMIT 0 ;
+CREATE TRIGGER r BEFORE INSERT ON `A` FOR EACH ROW INSERT INTO `view_AA` SELECT * FROM `view_C` LIMIT 0 ;
+ALTER TABLE `DD` DROP PRIMARY KEY;
+ERROR 42000: Incorrect table definition; there can be only one auto column and it must be defined as a key
+INSERT INTO `view_A` ( `pk` ) VALUES (NULL);
+INSERT INTO `DD` ( `pk` ) VALUES (NULL);
+INSERT INTO `A` ( `pk` ) VALUES (NULL);
+INSERT INTO `view_DD` ( `pk` ) VALUES (NULL);
+drop trigger r;
+drop trigger k;
+drop view view_A,view_AA,view_C,view_BB,view_DD;
+drop table A,C,AA,BB,DD;
+CREATE TABLE A (
+i INT,
+i1 INT,
+i2 INT,
+d1 DATE,
+d2 DATE,
+col_time_nokey1 TIME,
+col_time_nokey2 TIME,
+col_datetime_nokey1 DATETIME,
+col_datetime_nokey2 DATETIME,
+col_varchar_nokey1 VARCHAR(1),
+col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+CREATE VIEW view_A AS SELECT * FROM A;
+CREATE TABLE B (
+col_varchar_nokey VARCHAR(1)
+) ENGINE=MyISAM;
+CREATE TABLE AA (
+i INT,
+i1 INT,
+i2 INT,
+d1 DATE,
+d2 DATE,
+col_time_nokey1 TIME,
+col_time_nokey2 TIME,
+col_datetime_nokey1 DATETIME,
+col_datetime_nokey2 DATETIME,
+col_varchar_nokey1 VARCHAR(1),
+col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+CREATE VIEW view_AA AS SELECT * FROM AA;
+CREATE TABLE DD (
+i INT,
+i1 INT,
+i2 INT,
+d1 DATE,
+d2 DATE,
+col_time_nokey1 TIME,
+col_time_nokey2 TIME,
+col_datetime_nokey1 DATETIME,
+col_datetime_nokey2 DATETIME,
+col_varchar_nokey1 VARCHAR(1),
+col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+CREATE VIEW view_DD AS SELECT * FROM DD;
+CREATE TRIGGER tr1 BEFORE INSERT ON `AA` FOR EACH ROW INSERT INTO `view_A` SELECT * FROM `view_AA` LIMIT 0 ;
+CREATE TRIGGER tr2 BEFORE INSERT ON `B` FOR EACH ROW INSERT INTO `D` SELECT * FROM `A` LIMIT 0 ;
+INSERT INTO `view_AA` ( `i` ) VALUES (1);
+INSERT INTO `AA` ( `i` ) VALUES (2);
+DELETE FROM `B`;
+INSERT INTO `view_DD` ( `i` ) VALUES (1);
+INSERT INTO `view_AA` ( `i` ) VALUES (3);
+drop trigger tr1;
+drop trigger tr2;
+drop view view_A, view_AA,view_DD;
+drop table A,B,AA,DD;
diff --git a/mysql-test/t/sp-group.test b/mysql-test/t/sp-group.test
new file mode 100644
index 00000000000..2083ac97595
--- /dev/null
+++ b/mysql-test/t/sp-group.test
@@ -0,0 +1,187 @@
+--source include/have_innodb.inc
+
+drop table if exists t1;
+drop view if exists view_t1;
+
+#
+# Test case for MDEV 7601, MDEV-7594 and MDEV-7555
+# Server crashes in functions related to stored procedures
+# Server crashes in different ways while executing concurrent
+# flow involving views and non-empty sql_mode with ONLY_FULL_GROUP_BY
+#
+
+SET sql_mode=ONLY_FULL_GROUP_BY;
+
+CREATE TABLE t1 (
+  pk INT, 
+  f0 INT, f1 INT, f2 INT, f3 INT, f4 INT, 
+  f5 INT, f6 INT, f7 INT, f8 INT, f9 INT, 
+  PRIMARY KEY (pk)
+);
+
+CREATE VIEW view_t1 AS SELECT * FROM t1;
+CREATE PROCEDURE s1() 
+  SELECT * FROM (
+  INFORMATION_SCHEMA.`INNODB_BUFFER_PAGE_LRU` AS table1
+  LEFT JOIN test.view_t1 AS table2
+  ON ( table2.`f6` = table1.FREE_PAGE_CLOCK) 
+  ) 
+  ORDER BY table1.NUMBER_RECORDS
+  LIMIT 0
+;
+CALL s1;
+CALL s1;
+
+drop table t1;
+drop view view_t1;
+drop procedure s1;
+
+#
+# MDEV-7590
+# Server crashes in st_select_lex_unit::cleanup on executing a trigger
+#
+
+CREATE TABLE A (
+    pk INTEGER AUTO_INCREMENT,
+    col_int_key INTEGER,
+    col_varchar_key VARCHAR(1),
+    PRIMARY KEY (pk)
+) ENGINE=MyISAM;
+CREATE VIEW view_A AS SELECT * FROM A;
+CREATE TABLE C (
+    pk INTEGER AUTO_INCREMENT,
+    col_int_nokey INTEGER,
+    col_int_key INTEGER,
+    col_date_key DATE,
+    col_date_nokey DATE,
+    col_time_key TIME,
+    col_time_nokey TIME,
+    col_datetime_key DATETIME,
+    col_datetime_nokey DATETIME,
+    col_varchar_key VARCHAR(1),
+    col_varchar_nokey VARCHAR(1),
+    PRIMARY KEY (pk)
+) ENGINE=MyISAM;
+CREATE VIEW view_C AS SELECT * FROM C;
+CREATE TABLE AA (
+    pk INTEGER AUTO_INCREMENT,
+    col_int_nokey INTEGER,
+    col_int_key INTEGER,
+    col_date_key DATE,
+    col_date_nokey DATE,
+    col_time_key TIME,
+    col_time_nokey TIME,
+    col_datetime_key DATETIME,
+    col_datetime_nokey DATETIME,
+    col_varchar_key VARCHAR(1),
+    col_varchar_nokey VARCHAR(1),
+    PRIMARY KEY (pk),
+    KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_AA AS SELECT * FROM AA;
+CREATE TABLE BB (
+    pk INTEGER AUTO_INCREMENT,
+    col_int_key INTEGER,
+    col_varchar_key VARCHAR(1),
+    col_varchar_nokey VARCHAR(1),
+    PRIMARY KEY (pk),
+    KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_BB AS SELECT * FROM BB;
+CREATE TABLE DD (
+    pk INTEGER AUTO_INCREMENT,
+    col_int_key INTEGER,
+    col_date_key DATE,
+    col_time_key TIME,
+    col_datetime_key DATETIME,
+    col_varchar_key VARCHAR(1),
+    PRIMARY KEY (pk),
+    KEY (col_varchar_key, col_int_key)
+) ENGINE=MyISAM;
+CREATE VIEW view_DD AS SELECT * FROM DD;
+CREATE TRIGGER k BEFORE INSERT ON `DD` FOR EACH ROW INSERT INTO `view_BB` SELECT * FROM `view_A` LIMIT 0 ;
+CREATE TRIGGER r BEFORE INSERT ON `A` FOR EACH ROW INSERT INTO `view_AA` SELECT * FROM `view_C` LIMIT 0 ;
+--error ER_WRONG_AUTO_KEY
+ALTER TABLE `DD` DROP PRIMARY KEY;
+INSERT INTO `view_A` ( `pk` ) VALUES (NULL);
+--error 0,ER_WRONG_VALUE_COUNT_ON_ROW
+INSERT INTO `DD` ( `pk` ) VALUES (NULL);
+INSERT INTO `A` ( `pk` ) VALUES (NULL);
+--error 0,ER_WRONG_VALUE_COUNT_ON_ROW
+INSERT INTO `view_DD` ( `pk` ) VALUES (NULL);
+
+drop trigger r;
+drop trigger k;
+drop view view_A,view_AA,view_C,view_BB,view_DD;
+drop table A,C,AA,BB,DD;
+
+#
+# MDEV-7581
+# Server crashes in st_select_lex_unit::cleanup after a sequence of statements
+#
+
+CREATE TABLE A (
+ i INT,
+ i1 INT,
+ i2 INT,
+ d1 DATE,
+ d2 DATE,
+ col_time_nokey1 TIME,
+ col_time_nokey2 TIME,
+ col_datetime_nokey1 DATETIME,
+ col_datetime_nokey2 DATETIME,
+ col_varchar_nokey1 VARCHAR(1),
+ col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+
+CREATE VIEW view_A AS SELECT * FROM A;
+
+CREATE TABLE B (
+ col_varchar_nokey VARCHAR(1)
+) ENGINE=MyISAM;
+
+CREATE TABLE AA (
+ i INT,
+ i1 INT,
+ i2 INT,
+ d1 DATE,
+ d2 DATE,
+ col_time_nokey1 TIME,
+ col_time_nokey2 TIME,
+ col_datetime_nokey1 DATETIME,
+ col_datetime_nokey2 DATETIME,
+ col_varchar_nokey1 VARCHAR(1),
+ col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+
+CREATE VIEW view_AA AS SELECT * FROM AA;
+
+CREATE TABLE DD (
+ i INT,
+ i1 INT,
+ i2 INT,
+ d1 DATE,
+ d2 DATE,
+ col_time_nokey1 TIME,
+ col_time_nokey2 TIME,
+ col_datetime_nokey1 DATETIME,
+ col_datetime_nokey2 DATETIME,
+ col_varchar_nokey1 VARCHAR(1),
+ col_varchar_nokey2 VARCHAR(1)
+) ENGINE=MyISAM;
+
+CREATE VIEW view_DD AS SELECT * FROM DD;
+
+CREATE TRIGGER tr1 BEFORE INSERT ON `AA` FOR EACH ROW INSERT INTO `view_A` SELECT * FROM `view_AA` LIMIT 0 ; 
+CREATE TRIGGER tr2 BEFORE INSERT ON `B` FOR EACH ROW INSERT INTO `D` SELECT * FROM `A` LIMIT 0 ; 
+
+INSERT INTO `view_AA` ( `i` ) VALUES (1);
+INSERT INTO `AA` ( `i` ) VALUES (2);
+DELETE FROM `B`;
+INSERT INTO `view_DD` ( `i` ) VALUES (1);
+INSERT INTO `view_AA` ( `i` ) VALUES (3);
+
+drop trigger tr1;
+drop trigger tr2;
+drop view view_A, view_AA,view_DD;
+drop table A,B,AA,DD;
diff --git a/sql/item.cc b/sql/item.cc
index dbcf1b4cbe1..2f49ae46596 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -4883,7 +4883,7 @@ Item_field::fix_outer_field(THD *thd, Field **from_field, Item **reference)
             non aggregated fields of the outer select.
           */
           marker= select->cur_pos_in_select_list;
-          select->non_agg_fields.push_back(this);
+          select->join->non_agg_fields.push_back(this);
         }
         if (*from_field != view_ref_found)
         {
@@ -5299,9 +5299,10 @@ bool Item_field::fix_fields(THD *thd, Item **reference)
   fixed= 1;
   if (thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
       !outer_fixed && !thd->lex->in_sum_func &&
-      thd->lex->current_select->cur_pos_in_select_list != UNDEF_POS)
+      thd->lex->current_select->cur_pos_in_select_list != UNDEF_POS &&
+      thd->lex->current_select->join)
   {
-    thd->lex->current_select->non_agg_fields.push_back(this);
+    thd->lex->current_select->join->non_agg_fields.push_back(this);
     marker= thd->lex->current_select->cur_pos_in_select_list;
   }
 mark_non_agg_field:
diff --git a/sql/item.h b/sql/item.h
index 4aaa67d9a1d..a38a25dfc75 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -631,7 +631,7 @@ public:
   */
   uint name_length;                     /* Length of name */
   uint decimals;
-  int8 marker;
+  int  marker;
   bool maybe_null;			/* If item may be null */
   bool in_rollup;                       /* If used in GROUP BY list
                                            of a query with ROLLUP */ 
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 1d62acdbe4b..9ccafa75ca7 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -1917,7 +1917,6 @@ void st_select_lex::init_select()
   with_sum_func= 0;
   is_correlated= 0;
   cur_pos_in_select_list= UNDEF_POS;
-  non_agg_fields.empty();
   cond_value= having_value= Item::COND_UNDEF;
   inner_refs_list.empty();
   insert_tables= 0;
@@ -1925,6 +1924,7 @@ void st_select_lex::init_select()
   m_non_agg_field_used= false;
   m_agg_func_used= false;
   name_visibility_map= 0;
+  join= 0;
 }
 
 /*
diff --git a/sql/sql_lex.h b/sql/sql_lex.h
index a0f8e456800..aa59d76245b 100644
--- a/sql/sql_lex.h
+++ b/sql/sql_lex.h
@@ -877,8 +877,6 @@ public:
   bool no_wrap_view_item;
   /* exclude this select from check of unique_table() */
   bool exclude_from_table_unique_test;
-  /* List of fields that aren't under an aggregate function */
-  List<Item_field> non_agg_fields;
   /* index in the select list of the expression currently being fixed */
   int cur_pos_in_select_list;
 
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index fb7cafc595f..5ed7a67da61 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -20705,7 +20705,7 @@ setup_group(THD *thd, Item **ref_pointer_array, TABLE_LIST *tables,
     Item_field *field;
     int cur_pos_in_select_list= 0;
     List_iterator<Item> li(fields);
-    List_iterator<Item_field> naf_it(thd->lex->current_select->non_agg_fields);
+    List_iterator<Item_field> naf_it(thd->lex->current_select->join->non_agg_fields);
 
     field= naf_it++;
     while (field && (item=li++))
diff --git a/sql/sql_select.h b/sql/sql_select.h
index de5baeee151..4f807ff5b93 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -922,6 +922,9 @@ public:
   Item *pre_sort_idx_pushed_cond;
   void clean_pre_sort_join_tab();
 
+  /* List of fields that aren't under an aggregate function */
+  List<Item_field> non_agg_fields;
+
   /*
     For "Using temporary+Using filesort" queries, JOIN::join_tab can point to
     either: 
@@ -1301,6 +1304,7 @@ public:
     all_fields= fields_arg;
     if (&fields_list != &fields_arg)      /* Avoid valgrind-warning */
       fields_list= fields_arg;
+    non_agg_fields.empty();
     bzero((char*) &keyuse,sizeof(keyuse));
     tmp_table_param.init();
     tmp_table_param.end_write_records= HA_POS_ERROR;
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index 6e2e6e06ff7..87d3e86b2c7 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -1021,7 +1021,6 @@ bool st_select_lex::cleanup()
   {
     error= (bool) ((uint) error | (uint) lex_unit->cleanup());
   }
-  non_agg_fields.empty();
   inner_refs_list.empty();
   exclude_from_table_unique_test= FALSE;
   DBUG_RETURN(error);
@@ -1032,6 +1031,7 @@ void st_select_lex::cleanup_all_joins(bool full)
 {
   SELECT_LEX_UNIT *unit;
   SELECT_LEX *sl;
+  DBUG_ENTER("st_select_lex::cleanup_all_joins");
 
   if (join)
     join->cleanup(full);
@@ -1039,6 +1039,7 @@ void st_select_lex::cleanup_all_joins(bool full)
   for (unit= first_inner_unit(); unit; unit= unit->next_unit())
     for (sl= unit->first_select(); sl; sl= sl->next_select())
       sl->cleanup_all_joins(full);
+  DBUG_VOID_RETURN;
 }
 
 
diff --git a/sql/table.cc b/sql/table.cc
index e4dee77171d..f521056aaee 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -5194,7 +5194,7 @@ Item *Field_iterator_table::create_item(THD *thd)
   if (item && thd->variables.sql_mode & MODE_ONLY_FULL_GROUP_BY &&
       !thd->lex->in_sum_func && select->cur_pos_in_select_list != UNDEF_POS)
   {
-    select->non_agg_fields.push_back(item);
+    select->join->non_agg_fields.push_back(item);
     item->marker= select->cur_pos_in_select_list;
     select->set_non_agg_field_used(true);
   }
-- 
cgit v1.2.1


From 8c815751c92313dfa45ef0398b609c9988a0a451 Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Thu, 25 Jun 2015 23:26:29 +0300
Subject: Problem was that for cases like: SELECT ... WHERE XX IN (SELECT YY)
 this was transformed to something like: SELECT ... WHERE IF_EXISTS(SELECT ...
 HAVING XX=YY)

The bug was that for normal execution XX was fixed in the original outer SELECT context while in PS it was fixed in the sub query context and this confused the optimizer.

Fixed by ensuring that XX is always fixed in the outer context.
---
 mysql-test/r/subselect_mat.result    | 27 +++++++++++++++++++++++++++
 mysql-test/r/subselect_sj_mat.result | 27 +++++++++++++++++++++++++++
 mysql-test/t/subselect_sj_mat.test   | 21 ++++++++++++++++++++-
 sql/item_subselect.cc                | 21 ++++++++++++++++++++-
 sql/sql_base.cc                      |  3 +--
 sql/sql_select.cc                    | 12 +++++++-----
 6 files changed, 102 insertions(+), 9 deletions(-)

diff --git a/mysql-test/r/subselect_mat.result b/mysql-test/r/subselect_mat.result
index 7039bbfca15..8c25577eb01 100644
--- a/mysql-test/r/subselect_mat.result
+++ b/mysql-test/r/subselect_mat.result
@@ -2145,6 +2145,33 @@ drop database mysqltest1;
 drop database mysqltest2;
 drop database mysqltest3;
 drop database mysqltest4;
+#
+# MDEV-7810 Wrong result on execution of a query as a PS
+# (both 1st and further executions)
+CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
+INSERT INTO t1 VALUES (0),(8);
+SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
+a
+0
+8
+SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
+MIN(t3.a)
+0
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+a
+0
+PREPARE stmt FROM "
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+";
+execute stmt;
+a
+0
+execute stmt;
+a
+0
+drop table t1;
 # End of 5.5 tests
 set @subselect_mat_test_optimizer_switch_value=null;
 set @@optimizer_switch='materialization=on,in_to_exists=off,semijoin=off';
diff --git a/mysql-test/r/subselect_sj_mat.result b/mysql-test/r/subselect_sj_mat.result
index 58810670395..6c69d195bd3 100644
--- a/mysql-test/r/subselect_sj_mat.result
+++ b/mysql-test/r/subselect_sj_mat.result
@@ -2185,4 +2185,31 @@ drop database mysqltest1;
 drop database mysqltest2;
 drop database mysqltest3;
 drop database mysqltest4;
+#
+# MDEV-7810 Wrong result on execution of a query as a PS
+# (both 1st and further executions)
+CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
+INSERT INTO t1 VALUES (0),(8);
+SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
+a
+0
+8
+SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
+MIN(t3.a)
+0
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+a
+0
+PREPARE stmt FROM "
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+";
+execute stmt;
+a
+0
+execute stmt;
+a
+0
+drop table t1;
 # End of 5.5 tests
diff --git a/mysql-test/t/subselect_sj_mat.test b/mysql-test/t/subselect_sj_mat.test
index 912e9d5befd..63c72f20e21 100644
--- a/mysql-test/t/subselect_sj_mat.test
+++ b/mysql-test/t/subselect_sj_mat.test
@@ -1841,5 +1841,24 @@ drop database mysqltest2;
 drop database mysqltest3;
 drop database mysqltest4;
 
---echo # End of 5.5 tests
+--echo #
+--echo # MDEV-7810 Wrong result on execution of a query as a PS
+--echo # (both 1st and further executions)
+
+CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
+INSERT INTO t1 VALUES (0),(8);
+
+SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
+SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+PREPARE stmt FROM "
+SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
+WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+";
+execute stmt;
+execute stmt;
 
+drop table t1;
+
+--echo # End of 5.5 tests
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 62df666b71f..8b0c6efc9ee 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -1999,12 +1999,31 @@ Item_in_subselect::create_single_in_to_exists_cond(JOIN * join,
     during JOIN::optimize: this->tmp_having= this->having; this->having= 0;
   */
   Item* join_having= join->having ? join->having : join->tmp_having;
-
   DBUG_ENTER("Item_in_subselect::create_single_in_to_exists_cond");
 
   *where_item= NULL;
   *having_item= NULL;
 
+  /*
+    For PS we have to do fix_fields(expr) here to ensure that it's
+    evaluated in the outer context.  If not, then fix_having() will do
+    a fix_fields(expr) in the inner context and mark expr as
+    'depended', which will cause update_ref_and_keys() to find wrong
+    keys.
+    When not running PS, fix_fields(expr) as already been done earlier and
+    the following test does nothing.
+  */
+  if (expr && !expr->fixed)
+  {
+    SELECT_LEX *save_current_select= thd->lex->current_select;
+    thd->lex->current_select= thd->lex->current_select->outer_select();
+    bool tmp;
+    tmp= expr->fix_fields(thd, 0);
+    thd->lex->current_select= save_current_select;
+    if (tmp)
+      DBUG_RETURN(true);
+  }
+
   if (join_having || select_lex->with_sum_func ||
       select_lex->group_list.elements)
   {
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index fcd17b25b2d..aefa82405ff 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -6859,6 +6859,7 @@ find_field_in_tables(THD *thd, Item_ident *item,
 
   if (item->cached_table)
   {
+    DBUG_PRINT("info", ("using cached table"));
     /*
       This shortcut is used by prepared statements. We assume that
       TABLE_LIST *first_table is not changed during query execution (which
@@ -6935,8 +6936,6 @@ find_field_in_tables(THD *thd, Item_ident *item,
       return found;
     }
   }
-  else
-    item->can_be_depended= TRUE;
 
   if (db && lower_case_table_names)
   {
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 5ed7a67da61..e542b08f911 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -4904,6 +4904,8 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   KEY_FIELD *key_fields, *end, *field;
   uint sz;
   uint m= max(select_lex->max_equal_elems,1);
+  DBUG_ENTER("update_ref_and_keys");
+  DBUG_PRINT("enter", ("normal_tables: %llx", normal_tables));
 
   SELECT_LEX *sel=thd->lex->current_select; 
   sel->cond_count= 0;
@@ -4950,7 +4952,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   sz= max(sizeof(KEY_FIELD),sizeof(SARGABLE_PARAM))*
     ((sel->cond_count*2 + sel->between_count)*m+1);
   if (!(key_fields=(KEY_FIELD*)	thd->alloc(sz)))
-    return TRUE; /* purecov: inspected */
+    DBUG_RETURN(TRUE); /* purecov: inspected */
   and_level= 0;
   field= end= key_fields;
   *sargables= (SARGABLE_PARAM *) key_fields + 
@@ -4959,7 +4961,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   (*sargables)[0].field= 0; 
 
   if (my_init_dynamic_array(keyuse,sizeof(KEYUSE),20,64))
-    return TRUE;
+    DBUG_RETURN(TRUE);
 
   if (cond)
   {
@@ -5009,16 +5011,16 @@ update_ref_and_keys(THD *thd, DYNAMIC_ARRAY *keyuse,JOIN_TAB *join_tab,
   for ( ; field != end ; field++)
   {
     if (add_key_part(keyuse,field))
-      return TRUE;
+      DBUG_RETURN(TRUE);
   }
 
   if (select_lex->ftfunc_list->elements)
   {
     if (add_ft_keys(keyuse,join_tab,cond,normal_tables))
-      return TRUE;
+      DBUG_RETURN(TRUE);
   }
 
-  return FALSE;
+  DBUG_RETURN(FALSE);
 }
 
 
-- 
cgit v1.2.1


From 67c56ab1e4841058c40e6b61e1dcbb6e21d4ce52 Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Thu, 25 Jun 2015 23:34:54 +0300
Subject: Simple cleanups - Removing use of calls to current_thd - More
 DBUG_PRINT - Code style changes - Made some local functions static Ensure
 that calls to print_keyuse are locked with mutex to get all lines in same
 debug packet

---
 sql/item.cc           | 27 ++++++++++++++++-----------
 sql/item_subselect.cc |  5 ++++-
 sql/sql_test.cc       |  7 ++-----
 3 files changed, 22 insertions(+), 17 deletions(-)

diff --git a/sql/item.cc b/sql/item.cc
index 2f49ae46596..9b3e9a546c6 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -4415,18 +4415,23 @@ static bool mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
                               Item_ident *resolved_item,
                               Item_ident *mark_item)
 {
-  const char *db_name= (resolved_item->db_name ?
-                        resolved_item->db_name : "");
-  const char *table_name= (resolved_item->table_name ?
-                           resolved_item->table_name : "");
+  DBUG_ENTER("mark_as_dependent");
+
   /* store pointer on SELECT_LEX from which item is dependent */
   if (mark_item && mark_item->can_be_depended)
+  {
+    DBUG_PRINT("info", ("mark_item: %p  lex: %p", mark_item, last));
     mark_item->depended_from= last;
-  if (current->mark_as_dependent(thd, last, /** resolved_item psergey-thu
-    **/mark_item))
-    return TRUE;
+  }
+  if (current->mark_as_dependent(thd, last,
+                                 /** resolved_item psergey-thu **/ mark_item))
+    DBUG_RETURN(TRUE);
   if (thd->lex->describe & DESCRIBE_EXTENDED)
   {
+    const char *db_name= (resolved_item->db_name ?
+                          resolved_item->db_name : "");
+    const char *table_name= (resolved_item->table_name ?
+                             resolved_item->table_name : "");
     push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_NOTE,
 		 ER_WARN_FIELD_RESOLVED, ER(ER_WARN_FIELD_RESOLVED),
                  db_name, (db_name[0] ? "." : ""),
@@ -4434,7 +4439,7 @@ static bool mark_as_dependent(THD *thd, SELECT_LEX *last, SELECT_LEX *current,
                  resolved_item->field_name,
                  current->select_number, last->select_number);
   }
-  return FALSE;
+  DBUG_RETURN(FALSE);
 }
 
 
@@ -6886,7 +6891,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
       {
         /* The current reference cannot be resolved in this query. */
         my_error(ER_BAD_FIELD_ERROR,MYF(0),
-                 this->full_name(), current_thd->where);
+                 this->full_name(), thd->where);
         goto error;
       }
 
@@ -7021,7 +7026,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
           goto error;
         thd->change_item_tree(reference, fld);
         mark_as_dependent(thd, last_checked_context->select_lex,
-                          thd->lex->current_select, fld, fld);
+                          current_sel, fld, fld);
         /*
           A reference is resolved to a nest level that's outer or the same as
           the nest level of the enclosing set function : adjust the value of
@@ -7038,7 +7043,7 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
       {
         /* The item was not a table field and not a reference */
         my_error(ER_BAD_FIELD_ERROR, MYF(0),
-                 this->full_name(), current_thd->where);
+                 this->full_name(), thd->where);
         goto error;
       }
       /* Should be checked in resolve_ref_in_select_and_group(). */
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 8b0c6efc9ee..d31f7b8e5cb 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -464,6 +464,7 @@ void Item_subselect::recalc_used_tables(st_select_lex *new_parent,
 {
   List_iterator<Ref_to_outside> it(upper_refs);
   Ref_to_outside *upper;
+  DBUG_ENTER("recalc_used_tables");
   
   used_tables_cache= 0;
   while ((upper= it++))
@@ -523,6 +524,8 @@ void Item_subselect::recalc_used_tables(st_select_lex *new_parent,
     he has done const table detection, and that will be our chance to update
     const_tables_cache.
   */
+  DBUG_PRINT("exit", ("used_tables_cache: %llx", used_tables_cache));
+  DBUG_VOID_RETURN;
 }
 
 
@@ -1989,7 +1992,7 @@ bool Item_allany_subselect::is_maxmin_applicable(JOIN *join)
 */
 
 bool
-Item_in_subselect::create_single_in_to_exists_cond(JOIN * join,
+Item_in_subselect::create_single_in_to_exists_cond(JOIN *join,
                                                    Item **where_item,
                                                    Item **having_item)
 {
diff --git a/sql/sql_test.cc b/sql/sql_test.cc
index ec426e39ee3..dc6bc8187ff 100644
--- a/sql/sql_test.cc
+++ b/sql/sql_test.cc
@@ -248,7 +248,7 @@ TEST_join(JOIN *join)
 
 #define FT_KEYPART   (MAX_REF_PARTS+10)
 
-void print_keyuse(KEYUSE *keyuse)
+static void print_keyuse(KEYUSE *keyuse)
 {
   char buff[256];
   char buf2[64]; 
@@ -266,14 +266,11 @@ void print_keyuse(KEYUSE *keyuse)
   else
     fieldname= key_info->key_part[keyuse->keypart].field->field_name;
   ll2str(keyuse->used_tables, buf2, 16, 0); 
-  DBUG_LOCK_FILE;
   fprintf(DBUG_FILE, "KEYUSE: %s.%s=%s  optimize: %u  used_tables: %s "
           "ref_table_rows: %lu  keypart_map: %0lx\n",
           keyuse->table->alias.c_ptr(), fieldname, str.ptr(),
           (uint) keyuse->optimize, buf2, (ulong) keyuse->ref_table_rows, 
           (ulong) keyuse->keypart_map);
-  DBUG_UNLOCK_FILE;
-  //key_part_map keypart_map; --?? there can be several? 
 }
 
 
@@ -282,9 +279,9 @@ void print_keyuse_array(DYNAMIC_ARRAY *keyuse_array)
 {
   DBUG_LOCK_FILE;
   fprintf(DBUG_FILE, "KEYUSE array (%d elements)\n", keyuse_array->elements);
-  DBUG_UNLOCK_FILE;
   for(uint i=0; i < keyuse_array->elements; i++)
     print_keyuse((KEYUSE*)dynamic_array_ptr(keyuse_array, i));
+  DBUG_UNLOCK_FILE;
 }
 
 
-- 
cgit v1.2.1


From bc300464f1674dc774fd166a87d8894cbe498563 Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Fri, 26 Jun 2015 14:48:22 +0300
Subject: Fix for MDEV-8301;  Statistics for a thread could be counted twice in
 SHOW STATUS while thread was ending

Fixed by adding a marker if we have added the thread statistics to the global counters.
---
 sql/sql_class.cc |  2 ++
 sql/sql_class.h  | 11 ++++++++---
 sql/sql_show.cc  |  5 ++++-
 3 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 76b2031f553..a4a4b370658 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1263,6 +1263,7 @@ void THD::init(void)
   bzero((char *) &status_var, sizeof(status_var));
   bzero((char *) &org_status_var, sizeof(org_status_var));
   start_bytes_received= 0;
+  status_in_global= 0;
 
   if (variables.sql_log_bin)
     variables.option_bits|= OPTION_BIN_LOG;
@@ -1366,6 +1367,7 @@ void THD::change_user(void)
   cleanup();
   reset_killed();
   cleanup_done= 0;
+  status_in_global= 0;
   init();
   stmt_map.reset();
   my_hash_init(&user_vars, system_charset_info, USER_VARS_HASH_SIZE, 0, 0,
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 67db1662f10..17dd0f9f64f 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1733,11 +1733,11 @@ public:
   /* Do not set socket timeouts for wait_timeout (used with threadpool) */
   bool skip_wait_timeout;
 
-  /* container for handler's private per-connection data */
-  Ha_data ha_data[MAX_HA];
-
   bool prepare_derived_at_open;
 
+  /* Set to 1 if status of this THD is already in global status */
+  bool status_in_global;
+
   /* 
     To signal that the tmp table to be created is created for materialized
     derived table or a view.
@@ -1746,6 +1746,9 @@ public:
 
   bool save_prep_leaf_list;
 
+  /* container for handler's private per-connection data */
+  Ha_data ha_data[MAX_HA];
+
 #ifndef MYSQL_CLIENT
   binlog_cache_mngr *  binlog_setup_trx_data();
 
@@ -3116,6 +3119,8 @@ public:
   {
     mysql_mutex_lock(&LOCK_status);
     add_to_status(&global_status_var, &status_var);
+    /* Mark that this THD status has already been added in global status */
+    status_in_global= 1;
     mysql_mutex_unlock(&LOCK_status);
   }
 
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 22484748523..1e27e654318 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -3109,7 +3109,10 @@ void calc_sum_of_all_status(STATUS_VAR *to)
 
   /* Add to this status from existing threads */
   while ((tmp= it++))
-    add_to_status(to, &tmp->status_var);
+  {
+    if (!tmp->status_in_global)
+      add_to_status(to, &tmp->status_var);
+  }
   
   mysql_mutex_unlock(&LOCK_thread_count);
   DBUG_VOID_RETURN;
-- 
cgit v1.2.1


From 44de090a5fdcf799d826226055ee848af653e375 Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Fri, 17 Jul 2015 00:02:25 +0300
Subject: MDEV-8432 Slave cannot replicate signed integer-type values with high
 bit set to 1

The fix is that if the slave has a different integer size than
the master, then they will assume the master has the same signed/unsigned modifier
as the slave.

This means that one can safely change a coon the slave an int to a bigint
or an unsigned int to an unsigned int.  Changing an unsigned int to an
signed bigint will cause replication failures when the high bit of the
unsigned int is set.

We can't give an error if the signess is different on the master and slave
as the binary log doesn't contain the signess of the column on the master.
---
 mysql-test/suite/rpl/r/rpl_alter.result | 105 ++++++++++++++++++++++++++++++++
 mysql-test/suite/rpl/t/rpl_alter.test   |  53 ++++++++++++++++
 2 files changed, 158 insertions(+)

diff --git a/mysql-test/suite/rpl/r/rpl_alter.result b/mysql-test/suite/rpl/r/rpl_alter.result
index 2cffa70d778..7be3bc576f3 100644
--- a/mysql-test/suite/rpl/r/rpl_alter.result
+++ b/mysql-test/suite/rpl/r/rpl_alter.result
@@ -14,4 +14,109 @@ select * from mysqltest.t3;
 n
 45
 drop database mysqltest;
+use test;
+#
+# Test bug where ALTER TABLE MODIFY didn't replicate properly
+#
+create table t1 (a int unsigned primary key, b int);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` int(10) unsigned NOT NULL,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a bigint;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a int unsigned;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` int(10) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a bigint unsigned;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+use test;
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+create table t2 (a int unsigned auto_increment primary key, b int);
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+alter table t2 modify a bigint;
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` bigint(20) NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+alter table t2 modify a bigint auto_increment;
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` bigint(20) NOT NULL AUTO_INCREMENT,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+drop table t1,t2;
+#
+# MDEV-8432:  Slave cannot replicate signed integer-type values
+# with high bit set to 1
+# Test replication when we have int on master and bigint on slave
+#
+create table t1 (a int unsigned primary key, b int);
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+alter table t1 modify a bigint unsigned;
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+drop table t1;
 include/rpl_end.inc
diff --git a/mysql-test/suite/rpl/t/rpl_alter.test b/mysql-test/suite/rpl/t/rpl_alter.test
index 630197f8637..8b8bcfb3d26 100644
--- a/mysql-test/suite/rpl/t/rpl_alter.test
+++ b/mysql-test/suite/rpl/t/rpl_alter.test
@@ -15,4 +15,57 @@ drop database mysqltest;
 sync_slave_with_master;
 
 # End of 4.1 tests
+
+connection master;
+use test;
+
+--echo #
+--echo # Test bug where ALTER TABLE MODIFY didn't replicate properly
+--echo #
+
+create table t1 (a int unsigned primary key, b int);
+show create table t1;
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+alter table t1 modify a bigint;
+show create table t1;
+select * from t1;
+alter table t1 modify a int unsigned;
+show create table t1;
+select * from t1;
+alter table t1 modify a bigint unsigned;
+show create table t1;
+select * from t1;
+sync_slave_with_master;
+use test;
+select * from t1;
+show create table t1;
+connection master;
+#
+create table t2 (a int unsigned auto_increment primary key, b int);
+show create table t2;
+alter table t2 modify a bigint;
+show create table t2;
+alter table t2 modify a bigint auto_increment;
+show create table t2;
+drop table t1,t2;
+
+--echo #
+--echo # MDEV-8432:  Slave cannot replicate signed integer-type values
+--echo # with high bit set to 1
+--echo # Test replication when we have int on master and bigint on slave
+--echo #
+
+create table t1 (a int unsigned primary key, b int);
+sync_slave_with_master;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+alter table t1 modify a bigint unsigned;
+connection master;
+insert into t1 (a) values (1),((1<<32)-1);
+sync_slave_with_master;
+select * from t1;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+connection master;
+drop table t1;
+
 --source include/rpl_end.inc
-- 
cgit v1.2.1


From 00d3b20fbb669840daebf2a4483cead92221d78c Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Fri, 17 Jul 2015 00:06:27 +0300
Subject: MDEV-8432 Slave cannot replicate signed integer-type values with high
 bit set to 1

The fix is that if the slave has a different integer size than
the master, then they will assume the master has the same signed/unsigned modifier
as the slave.

This means that one can safely change a coon the slave an int to a bigint
or an unsigned int to an unsigned int.  Changing an unsigned int to an
signed bigint will cause replication failures when the high bit of the
unsigned int is set.

We can't give an error if the signess is different on the master and slave
as the binary log doesn't contain the signess of the column on the master.
---
 mysql-test/suite/rpl/r/rpl_alter.result | 105 ++++++++++++++++++++++++++++++++
 mysql-test/suite/rpl/t/rpl_alter.test   |  53 ++++++++++++++++
 sql/rpl_utility.cc                      |  21 +++++--
 3 files changed, 175 insertions(+), 4 deletions(-)

diff --git a/mysql-test/suite/rpl/r/rpl_alter.result b/mysql-test/suite/rpl/r/rpl_alter.result
index 2cffa70d778..7be3bc576f3 100644
--- a/mysql-test/suite/rpl/r/rpl_alter.result
+++ b/mysql-test/suite/rpl/r/rpl_alter.result
@@ -14,4 +14,109 @@ select * from mysqltest.t3;
 n
 45
 drop database mysqltest;
+use test;
+#
+# Test bug where ALTER TABLE MODIFY didn't replicate properly
+#
+create table t1 (a int unsigned primary key, b int);
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` int(10) unsigned NOT NULL,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a bigint;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a int unsigned;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` int(10) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+alter table t1 modify a bigint unsigned;
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+use test;
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+show create table t1;
+Table	Create Table
+t1	CREATE TABLE `t1` (
+  `a` bigint(20) unsigned NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+create table t2 (a int unsigned auto_increment primary key, b int);
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` int(10) unsigned NOT NULL AUTO_INCREMENT,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+alter table t2 modify a bigint;
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` bigint(20) NOT NULL DEFAULT '0',
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+alter table t2 modify a bigint auto_increment;
+show create table t2;
+Table	Create Table
+t2	CREATE TABLE `t2` (
+  `a` bigint(20) NOT NULL AUTO_INCREMENT,
+  `b` int(11) DEFAULT NULL,
+  PRIMARY KEY (`a`)
+) ENGINE=MyISAM DEFAULT CHARSET=latin1
+drop table t1,t2;
+#
+# MDEV-8432:  Slave cannot replicate signed integer-type values
+# with high bit set to 1
+# Test replication when we have int on master and bigint on slave
+#
+create table t1 (a int unsigned primary key, b int);
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+alter table t1 modify a bigint unsigned;
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+a	b
+1	NULL
+4294967295	NULL
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+drop table t1;
 include/rpl_end.inc
diff --git a/mysql-test/suite/rpl/t/rpl_alter.test b/mysql-test/suite/rpl/t/rpl_alter.test
index 630197f8637..8b8bcfb3d26 100644
--- a/mysql-test/suite/rpl/t/rpl_alter.test
+++ b/mysql-test/suite/rpl/t/rpl_alter.test
@@ -15,4 +15,57 @@ drop database mysqltest;
 sync_slave_with_master;
 
 # End of 4.1 tests
+
+connection master;
+use test;
+
+--echo #
+--echo # Test bug where ALTER TABLE MODIFY didn't replicate properly
+--echo #
+
+create table t1 (a int unsigned primary key, b int);
+show create table t1;
+insert into t1 (a) values (1),((1<<32)-1);
+select * from t1;
+alter table t1 modify a bigint;
+show create table t1;
+select * from t1;
+alter table t1 modify a int unsigned;
+show create table t1;
+select * from t1;
+alter table t1 modify a bigint unsigned;
+show create table t1;
+select * from t1;
+sync_slave_with_master;
+use test;
+select * from t1;
+show create table t1;
+connection master;
+#
+create table t2 (a int unsigned auto_increment primary key, b int);
+show create table t2;
+alter table t2 modify a bigint;
+show create table t2;
+alter table t2 modify a bigint auto_increment;
+show create table t2;
+drop table t1,t2;
+
+--echo #
+--echo # MDEV-8432:  Slave cannot replicate signed integer-type values
+--echo # with high bit set to 1
+--echo # Test replication when we have int on master and bigint on slave
+--echo #
+
+create table t1 (a int unsigned primary key, b int);
+sync_slave_with_master;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='ALL_NON_LOSSY';
+alter table t1 modify a bigint unsigned;
+connection master;
+insert into t1 (a) values (1),((1<<32)-1);
+sync_slave_with_master;
+select * from t1;
+SET GLOBAL SLAVE_TYPE_CONVERSIONS='';
+connection master;
+drop table t1;
+
 --source include/rpl_end.inc
diff --git a/sql/rpl_utility.cc b/sql/rpl_utility.cc
index e05ad5a8d43..9a20f71f4f7 100644
--- a/sql/rpl_utility.cc
+++ b/sql/rpl_utility.cc
@@ -876,6 +876,7 @@ TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli, TABLE *
   {
     Create_field *field_def=
       (Create_field*) alloc_root(thd->mem_root, sizeof(Create_field));
+    bool unsigned_flag= 0;
     if (field_list.push_back(field_def))
       DBUG_RETURN(NULL);
 
@@ -885,8 +886,7 @@ TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli, TABLE *
     uint32 max_length=
       max_display_length_for_field(type(col), field_metadata(col));
 
-    switch(type(col))
-    {
+    switch(type(col)) {
       int precision;
     case MYSQL_TYPE_ENUM:
     case MYSQL_TYPE_SET:
@@ -925,6 +925,18 @@ TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli, TABLE *
       pack_length= field_metadata(col) & 0x00ff;
       break;
 
+    case MYSQL_TYPE_TINY:
+    case MYSQL_TYPE_SHORT:
+    case MYSQL_TYPE_INT24:
+    case MYSQL_TYPE_LONG:
+    case MYSQL_TYPE_LONGLONG:
+      /*
+        As we don't know if the integer was signed or not on the master,
+        assume we have same sign on master and slave.  This is true when not
+        using conversions so it should be true also when using conversions.
+      */
+      unsigned_flag= ((Field_num*) target_table->field[col])->unsigned_flag;
+      break;
     default:
       break;
     }
@@ -932,12 +944,13 @@ TABLE *table_def::create_conversion_table(THD *thd, Relay_log_info *rli, TABLE *
     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));
+                         max_length, decimals, TRUE, unsigned_flag,
+                         pack_length));
     field_def->init_for_tmp_table(type(col),
                                   max_length,
                                   decimals,
                                   TRUE,         // maybe_null
-                                  FALSE,        // unsigned_flag
+                                  unsigned_flag,
                                   pack_length);
     field_def->charset= target_table->field[col]->charset();
     field_def->interval= interval;
-- 
cgit v1.2.1


From 7a9670218b2d1b5673432ebf4e0f028a7c963494 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= <jan.lindstrom@mariadb.com>
Date: Tue, 21 Jul 2015 12:12:58 +0300
Subject: MDEV-8474: InnoDB sets per-connection data unsafely

Analysis: At check_trx_exists function InnoDB allocates
a new trx if no trx is found from thd but this newly
allocated trx is not registered to thd. This is unsafe,
because nothing prevents InnoDB plugin from being uninstalled
while there's active transaction. This can cause crashes, hang
and any other odd behavior. It may also corrupt stack, as
functions pointers are not available after dlclose.

Fix: The fix is to use thd_set_ha_data() when
manipulating per-connection handler data. It does appropriate
plugin locking.
---
 mysql-test/mysql-test-run.pl                      |  1 +
 mysql-test/r/innodb_load_xa.result                |  2 +
 mysql-test/suite/innodb/r/innodb_uninstall.result | 22 +++++++++
 mysql-test/suite/innodb/t/innodb_uninstall.opt    |  3 ++
 mysql-test/suite/innodb/t/innodb_uninstall.test   | 58 +++++++++++++++++++++++
 mysql-test/t/innodb_load_xa.test                  |  3 ++
 storage/innobase/handler/ha_innodb.cc             |  1 +
 storage/xtradb/handler/ha_innodb.cc               |  1 +
 8 files changed, 91 insertions(+)
 create mode 100644 mysql-test/suite/innodb/r/innodb_uninstall.result
 create mode 100644 mysql-test/suite/innodb/t/innodb_uninstall.opt
 create mode 100644 mysql-test/suite/innodb/t/innodb_uninstall.test

diff --git a/mysql-test/mysql-test-run.pl b/mysql-test/mysql-test-run.pl
index 566423a1c07..26b31d34d3c 100755
--- a/mysql-test/mysql-test-run.pl
+++ b/mysql-test/mysql-test-run.pl
@@ -4806,6 +4806,7 @@ sub extract_warning_lines ($$) {
      qr|Plugin 'FEEDBACK' registration as a INFORMATION SCHEMA failed|,
      qr|Failed to setup SSL|,
      qr|SSL error: Failed to set ciphers to use|,
+     qr/Plugin 'InnoDB' will be forced to shutdown/,
     );
 
   my $matched_lines= [];
diff --git a/mysql-test/r/innodb_load_xa.result b/mysql-test/r/innodb_load_xa.result
index e738ca6e3af..8b8de2032e5 100644
--- a/mysql-test/r/innodb_load_xa.result
+++ b/mysql-test/r/innodb_load_xa.result
@@ -18,3 +18,5 @@ mysqld-bin.000001	#	Query	#	#	use `test`; insert t1 values (2)
 mysqld-bin.000001	#	Query	#	#	COMMIT
 drop table t1;
 uninstall plugin innodb;
+Warnings:
+Warning	1620	Plugin is busy and will be uninstalled on shutdown
diff --git a/mysql-test/suite/innodb/r/innodb_uninstall.result b/mysql-test/suite/innodb/r/innodb_uninstall.result
new file mode 100644
index 00000000000..2064269a02e
--- /dev/null
+++ b/mysql-test/suite/innodb/r/innodb_uninstall.result
@@ -0,0 +1,22 @@
+install plugin innodb soname 'ha_innodb';
+create table t1(a int not null primary key) engine=innodb;
+begin;
+insert into t1 values(1);
+flush tables;
+uninstall plugin innodb;
+select sleep(1);
+sleep(1)
+0
+Warnings:
+Warning	1620	Plugin is busy and will be uninstalled on shutdown
+drop table t1;
+install plugin innodb soname 'ha_innodb';
+create table t2(a int not null primary key) engine=innodb;
+insert into t2 values(1);
+drop table t2;
+uninstall plugin innodb;
+select sleep(1);
+sleep(1)
+0
+Warnings:
+Warning	1620	Plugin is busy and will be uninstalled on shutdown
diff --git a/mysql-test/suite/innodb/t/innodb_uninstall.opt b/mysql-test/suite/innodb/t/innodb_uninstall.opt
new file mode 100644
index 00000000000..918855a7b01
--- /dev/null
+++ b/mysql-test/suite/innodb/t/innodb_uninstall.opt
@@ -0,0 +1,3 @@
+--ignore-builtin-innodb
+--loose-innodb
+
diff --git a/mysql-test/suite/innodb/t/innodb_uninstall.test b/mysql-test/suite/innodb/t/innodb_uninstall.test
new file mode 100644
index 00000000000..34fc8345a02
--- /dev/null
+++ b/mysql-test/suite/innodb/t/innodb_uninstall.test
@@ -0,0 +1,58 @@
+--source include/not_embedded.inc
+--source include/not_windows.inc
+
+if (!$HA_INNODB_SO) {
+  --skip Need InnoDB plugin
+}
+
+#
+# MDEV-8474: InnoDB sets per-connection data unsafely
+# Below test caused hang
+#
+install plugin innodb soname 'ha_innodb';
+create table t1(a int not null primary key) engine=innodb;
+
+connect (con1, localhost, root);
+connection con1;
+begin;
+insert into t1 values(1);
+
+connection default;
+flush tables;
+send uninstall plugin innodb;
+
+connection con1;
+select sleep(1);
+disconnect con1;
+
+connection default;
+reap;
+
+--source include/restart_mysqld.inc
+
+drop table t1;
+
+#
+# Another test that caused hang.
+#
+
+connect (con1, localhost, root);
+connection con1;
+install plugin innodb soname 'ha_innodb';
+create table t2(a int not null primary key) engine=innodb;
+insert into t2 values(1);
+drop table t2;
+
+connection default;
+send uninstall plugin innodb;
+
+connection con1;
+select sleep(1);
+disconnect con1;
+
+connection default;
+reap;
+
+--source include/restart_mysqld.inc
+
+
diff --git a/mysql-test/t/innodb_load_xa.test b/mysql-test/t/innodb_load_xa.test
index 52862151b22..9ecddde5d13 100644
--- a/mysql-test/t/innodb_load_xa.test
+++ b/mysql-test/t/innodb_load_xa.test
@@ -16,3 +16,6 @@ commit;
 --source include/show_binlog_events.inc
 drop table t1;
 uninstall plugin innodb;
+
+--source include/restart_mysqld.inc
+
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index 7c17f20ce40..c97b5bfadc2 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -1597,6 +1597,7 @@ check_trx_exists(
 
 	if (trx == NULL) {
 		trx = innobase_trx_allocate(thd);
+		thd_set_ha_data(thd, innodb_hton_ptr, trx);
 	} else if (UNIV_UNLIKELY(trx->magic_n != TRX_MAGIC_N)) {
 		mem_analyze_corruption(trx);
 		ut_error;
diff --git a/storage/xtradb/handler/ha_innodb.cc b/storage/xtradb/handler/ha_innodb.cc
index 5034e7e70e1..fa0081da436 100644
--- a/storage/xtradb/handler/ha_innodb.cc
+++ b/storage/xtradb/handler/ha_innodb.cc
@@ -1853,6 +1853,7 @@ check_trx_exists(
 
 	if (trx == NULL) {
 		trx = innobase_trx_allocate(thd);
+		thd_set_ha_data(thd, innodb_hton_ptr, trx);
 	} else if (UNIV_UNLIKELY(trx->magic_n != TRX_MAGIC_N)) {
 		mem_analyze_corruption(trx);
 		ut_error;
-- 
cgit v1.2.1


From 7115341473947882994a5857db8113f7b08a516f Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Thu, 23 Jul 2015 14:57:12 +0300
Subject: Fixed warnings and errors found by buildbot

field.cc
- Fixed warning about overlapping memory copy (backport from 10.0)

Item_subselect.cc
- Fixed core dump in main.view
- Problem was that thd->lex->current_select->master_unit()->item was not set, which caused crash in maxr_as_dependent

sql/mysqld.cc
- Got error on shutdown as we where freeing mutex before all THD objects was freed
  (~THD uses some mutex). Fixed by during shutdown freeing THD inside mutex.

sql/log.cc
- log_space_lock and LOCK_log where locked in inconsistenly. Fixed by not having a log_space_lock around purge_logs.

sql/slave.cc
- Remove unnecessary log_space_lock
- Move cond_broadcast inside lock to ensure we don't miss the signal
---
 sql/field.cc          |  3 ++-
 sql/item_subselect.cc | 13 ++++++++++++-
 sql/log.cc            | 33 +++++++++++++++------------------
 sql/mysqld.cc         | 11 ++++++++++-
 sql/slave.cc          | 10 +---------
 5 files changed, 40 insertions(+), 30 deletions(-)

diff --git a/sql/field.cc b/sql/field.cc
index a24ffe28600..aeeacf7f88d 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -7612,7 +7612,8 @@ int Field_geom::store(const char *from, uint length, CHARSET_INFO *cs)
     }
 
     Field_blob::store_length(length);
-    if (table->copy_blobs || length <= MAX_FIELD_WIDTH)
+    if ((table->copy_blobs || length <= MAX_FIELD_WIDTH) &&
+        from != value.ptr())
     {						// Must make a copy
       value.copy(from, length, cs);
       from= value.ptr();
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index d31f7b8e5cb..3b280c45608 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -2018,10 +2018,21 @@ Item_in_subselect::create_single_in_to_exists_cond(JOIN *join,
   */
   if (expr && !expr->fixed)
   {
+    bool tmp;
     SELECT_LEX *save_current_select= thd->lex->current_select;
+    Item_subselect *save_item;
+
     thd->lex->current_select= thd->lex->current_select->outer_select();
-    bool tmp;
+    /*
+      For st_select_lex::mark_as_dependent, who needs to mark
+      this sub query as correlated.
+    */
+    save_item= thd->lex->current_select->master_unit()->item;
+    thd->lex->current_select->master_unit()->item= this;
+
     tmp= expr->fix_fields(thd, 0);
+
+    thd->lex->current_select->master_unit()->item= save_item;
     thd->lex->current_select= save_current_select;
     if (tmp)
       DBUG_RETURN(true);
diff --git a/sql/log.cc b/sql/log.cc
index 9722f20869d..0940cb9b56c 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -3676,6 +3676,7 @@ int MYSQL_BIN_LOG::purge_first_log(Relay_log_info* rli, bool included)
 {
   int error;
   char *to_purge_if_included= NULL;
+  ulonglong log_space_reclaimed= 0;
   DBUG_ENTER("purge_first_log");
 
   DBUG_ASSERT(is_open());
@@ -3724,17 +3725,13 @@ int MYSQL_BIN_LOG::purge_first_log(Relay_log_info* rli, bool included)
 
   DBUG_EXECUTE_IF("crash_before_purge_logs", DBUG_SUICIDE(););
 
-  mysql_mutex_lock(&rli->log_space_lock);
   rli->relay_log.purge_logs(to_purge_if_included, included,
-                            0, 0, &rli->log_space_total);
-  mysql_mutex_unlock(&rli->log_space_lock);
+                            0, 0, &log_space_reclaimed);
 
-  /*
-    Ok to broadcast after the critical region as there is no risk of
-    the mutex being destroyed by this thread later - this helps save
-    context switches
-  */
+  mysql_mutex_lock(&rli->log_space_lock);
+  rli->log_space_total-= log_space_reclaimed;
   mysql_cond_broadcast(&rli->log_space_cond);
+  mysql_mutex_unlock(&rli->log_space_lock);
 
   /*
    * Need to update the log pos because purge logs has been called 
@@ -3783,8 +3780,8 @@ int MYSQL_BIN_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads
   @param need_mutex
   @param need_update_threads If we want to update the log coordinates of
                              all threads. False for relay logs, true otherwise.
-  @param freed_log_space     If not null, decrement this variable of
-                             the amount of log space freed
+  @param reclaimeed_log_space If not null, increment this variable to
+                              the amount of log space freed
 
   @note
     If any of the logs before the deleted one is in use,
@@ -3800,10 +3797,10 @@ int MYSQL_BIN_LOG::update_log_index(LOG_INFO* log_info, bool need_update_threads
 */
 
 int MYSQL_BIN_LOG::purge_logs(const char *to_log, 
-                          bool included,
-                          bool need_mutex, 
-                          bool need_update_threads, 
-                          ulonglong *decrease_log_space)
+                              bool included,
+                              bool need_mutex, 
+                              bool need_update_threads, 
+                              ulonglong *reclaimed_space)
 {
   int error= 0;
   bool exit_loop= 0;
@@ -3868,7 +3865,7 @@ int MYSQL_BIN_LOG::purge_logs(const char *to_log,
 err:
   /* Read each entry from purge_index_file and delete the file. */
   if (is_inited_purge_index_file() &&
-      (error= purge_index_entry(thd, decrease_log_space, FALSE)))
+      (error= purge_index_entry(thd, reclaimed_space, FALSE)))
     sql_print_error("MSYQL_BIN_LOG::purge_logs failed to process registered files"
                     " that would be purged.");
   close_purge_index_file();
@@ -3973,7 +3970,7 @@ int MYSQL_BIN_LOG::register_create_index_entry(const char *entry)
   DBUG_RETURN(register_purge_index_entry(entry));
 }
 
-int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space,
+int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *reclaimed_space,
                                      bool need_mutex)
 {
   DBUG_ENTER("MYSQL_BIN_LOG:purge_index_entry");
@@ -4093,8 +4090,8 @@ int MYSQL_BIN_LOG::purge_index_entry(THD *thd, ulonglong *decrease_log_space,
         DBUG_PRINT("info",("purging %s",log_info.log_file_name));
         if (!my_delete(log_info.log_file_name, MYF(0)))
         {
-          if (decrease_log_space)
-            *decrease_log_space-= s.st_size;
+          if (reclaimed_space)
+            *reclaimed_space+= s.st_size;
         }
         else
         {
diff --git a/sql/mysqld.cc b/sql/mysqld.cc
index 0178f927bab..1f741bf0a65 100644
--- a/sql/mysqld.cc
+++ b/sql/mysqld.cc
@@ -2488,7 +2488,6 @@ void unlink_thd(THD *thd)
   thd->add_status_to_global();
 
   mysql_mutex_lock(&LOCK_thread_count);
-  thread_count--;
   thd->unlink();
   /*
     Used by binlog_reset_master.  It would be cleaner to use
@@ -2496,6 +2495,16 @@ void unlink_thd(THD *thd)
     sync feature has been shut down at this point.
   */
   DBUG_EXECUTE_IF("sleep_after_lock_thread_count_before_delete_thd", sleep(5););
+  if (unlikely(abort_loop))
+  {
+    /*
+      During shutdown, we have to delete thd inside the mutex
+      to not refer to mutexes that may be deleted during shutdown
+    */
+    delete thd;
+    thd= 0;
+  }
+  thread_count--;
   mysql_mutex_unlock(&LOCK_thread_count);
 
   delete thd;
diff --git a/sql/slave.cc b/sql/slave.cc
index 2fe7ebb575d..fe96b1de008 100644
--- a/sql/slave.cc
+++ b/sql/slave.cc
@@ -3556,9 +3556,7 @@ pthread_handler_t handle_slave_sql(void *arg)
   rli->clear_error();
 
   //tell the I/O thread to take relay_log_space_limit into account from now on
-  mysql_mutex_lock(&rli->log_space_lock);
   rli->ignore_log_space_limit= 0;
-  mysql_mutex_unlock(&rli->log_space_lock);
   rli->trans_retries= 0; // start from "no error"
   DBUG_PRINT("info", ("rli->trans_retries: %lu", rli->trans_retries));
 
@@ -5228,14 +5226,8 @@ static Log_event* next_event(Relay_log_info* rli)
           rli->ignore_log_space_limit= true;
         }
 
-        /*
-          If the I/O thread is blocked, unblock it.  Ok to broadcast
-          after unlock, because the mutex is only destroyed in
-          ~Relay_log_info(), i.e. when rli is destroyed, and rli will
-          not be destroyed before we exit the present function.
-        */
-        mysql_mutex_unlock(&rli->log_space_lock);
         mysql_cond_broadcast(&rli->log_space_cond);
+        mysql_mutex_unlock(&rli->log_space_lock);
         // Note that wait_for_update_relay_log unlocks lock_log !
         rli->relay_log.wait_for_update_relay_log(rli->sql_thd);
         // re-acquire data lock since we released it earlier
-- 
cgit v1.2.1


From e40bc659335f7f8b69427ed2d215c34c045a5ed7 Mon Sep 17 00:00:00 2001
From: Monty <monty@mariadb.org>
Date: Sat, 25 Jul 2015 15:14:40 +0300
Subject: Fixed memory loss detected on P8. This can happen when we call
 after_flush but never call after_rollback() or after_commit().

The old code used pthread_setspecific() to store temporary data used by the thread.
This is not safe when used with thread pool, as the thread may change for the transaction.

The fix is to save the data in THD, which is guaranteed to be properly freed.
I also fixed the code so that we don't do a malloc() for every transaction.
---
 sql/rpl_handler.cc | 54 ++++++++++++++++++++++--------------------------------
 sql/sql_class.cc   |  2 ++
 sql/sql_class.h    |  5 ++++-
 3 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/sql/rpl_handler.cc b/sql/rpl_handler.cc
index 9480a9e0454..5b75d6c30ea 100644
--- a/sql/rpl_handler.cc
+++ b/sql/rpl_handler.cc
@@ -38,8 +38,6 @@ typedef struct Trans_binlog_info {
   char log_file[FN_REFLEN];
 } Trans_binlog_info;
 
-static pthread_key(Trans_binlog_info*, RPL_TRANS_BINLOG_INFO);
-
 int get_user_var_int(const char *name,
                      long long int *value, int *null_value)
 {
@@ -143,13 +141,6 @@ int delegates_init()
   }
 #endif
 
-  if (pthread_key_create(&RPL_TRANS_BINLOG_INFO, NULL))
-  {
-    sql_print_error("Error while creating pthread specific data key for replication. "
-                    "Please report a bug.");
-    return 1;
-  }
-
   return 0;
 }
 
@@ -195,27 +186,27 @@ void delegates_destroy()
 int Trans_delegate::after_commit(THD *thd, bool all)
 {
   Trans_param param;
+  Trans_binlog_info *log_info;
   bool is_real_trans= (all || thd->transaction.all.ha_list == 0);
+  int ret= 0;
 
   param.flags = is_real_trans ? TRANS_IS_REAL_TRANS : 0;
 
-  Trans_binlog_info *log_info=
-    my_pthread_getspecific_ptr(Trans_binlog_info*, RPL_TRANS_BINLOG_INFO);
+  log_info= thd->semisync_info;
 
-  param.log_file= log_info ? log_info->log_file : 0;
+  param.log_file= log_info && log_info->log_file[0] ? log_info->log_file : 0;
   param.log_pos= log_info ? log_info->log_pos : 0;
 
-  int ret= 0;
   FOREACH_OBSERVER(ret, after_commit, false, (&param));
 
   /*
     This is the end of a real transaction or autocommit statement, we
-    can free the memory allocated for binlog file and position.
+    can mark the memory unused.
   */
   if (is_real_trans && log_info)
   {
-    my_pthread_setspecific_ptr(RPL_TRANS_BINLOG_INFO, NULL);
-    my_free(log_info);
+    log_info->log_file[0]= 0;
+    log_info->log_pos= 0;
   }
   return ret;
 }
@@ -223,27 +214,27 @@ int Trans_delegate::after_commit(THD *thd, bool all)
 int Trans_delegate::after_rollback(THD *thd, bool all)
 {
   Trans_param param;
+  Trans_binlog_info *log_info;
   bool is_real_trans= (all || thd->transaction.all.ha_list == 0);
+  int ret= 0;
 
   param.flags = is_real_trans ? TRANS_IS_REAL_TRANS : 0;
 
-  Trans_binlog_info *log_info=
-    my_pthread_getspecific_ptr(Trans_binlog_info*, RPL_TRANS_BINLOG_INFO);
-    
-  param.log_file= log_info ? log_info->log_file : 0;
+  log_info= thd->semisync_info;
+
+  param.log_file= log_info && log_info->log_file[0] ? log_info->log_file : 0;
   param.log_pos= log_info ? log_info->log_pos : 0;
 
-  int ret= 0;
   FOREACH_OBSERVER(ret, after_rollback, false, (&param));
 
   /*
     This is the end of a real transaction or autocommit statement, we
-    can free the memory allocated for binlog file and position.
+    can mark the memory unused.
   */
   if (is_real_trans && log_info)
   {
-    my_pthread_setspecific_ptr(RPL_TRANS_BINLOG_INFO, NULL);
-    my_free(log_info);
+    log_info->log_file[0]= 0;
+    log_info->log_pos= 0;
   }
   return ret;
 }
@@ -254,25 +245,24 @@ int Binlog_storage_delegate::after_flush(THD *thd,
                                          bool synced)
 {
   Binlog_storage_param param;
+  Trans_binlog_info *log_info;
   uint32 flags=0;
+  int ret= 0;
+
   if (synced)
     flags |= BINLOG_STORAGE_IS_SYNCED;
 
-  Trans_binlog_info *log_info=
-    my_pthread_getspecific_ptr(Trans_binlog_info*, RPL_TRANS_BINLOG_INFO);
-    
-  if (!log_info)
+  if (!(log_info= thd->semisync_info))
   {
     if(!(log_info=
-         (Trans_binlog_info *)my_malloc(sizeof(Trans_binlog_info), MYF(0))))
+         (Trans_binlog_info*) my_malloc(sizeof(Trans_binlog_info), MYF(0))))
       return 1;
-    my_pthread_setspecific_ptr(RPL_TRANS_BINLOG_INFO, log_info);
+    thd->semisync_info= log_info;
   }
-    
+
   strcpy(log_info->log_file, log_file+dirname_length(log_file));
   log_info->log_pos = log_pos;
   
-  int ret= 0;
   FOREACH_OBSERVER(ret, after_flush, false,
                    (&param, log_info->log_file, log_info->log_pos, flags));
   return ret;
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index a4a4b370658..7b97d5839fc 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -877,6 +877,7 @@ THD::THD()
   file_id = 0;
   query_id= 0;
   query_name_consts= 0;
+  semisync_info= 0;
   db_charset= global_system_variables.collation_database;
   bzero(ha_data, sizeof(ha_data));
   mysys_var=0;
@@ -1493,6 +1494,7 @@ THD::~THD()
   mysql_audit_free_thd(this);
   if (rli_slave)
     rli_slave->cleanup_after_session();
+  my_free(semisync_info);
 #endif
 
   free_root(&main_mem_root, MYF(0));
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 17dd0f9f64f..8d51120e428 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -47,7 +47,6 @@
 
 class Reprepare_observer;
 class Relay_log_info;
-
 class Query_log_event;
 class Load_log_event;
 class Slave_log_event;
@@ -59,6 +58,7 @@ class Rows_log_event;
 class Sroutine_hash_entry;
 class User_level_lock;
 class user_var_entry;
+class Trans_binlog_info;
 
 enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
 enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
@@ -1670,6 +1670,9 @@ public:
   */
   const char *where;
 
+  /* Needed by MariaDB semi sync replication */
+  Trans_binlog_info *semisync_info;
+
   ulong client_capabilities;		/* What the client supports */
   ulong max_client_packet_length;
 
-- 
cgit v1.2.1


From 392df76bc3a40a5dd1956b12628dd6489a37be36 Mon Sep 17 00:00:00 2001
From: Sergey Vojtovich <svoj@mariadb.org>
Date: Thu, 23 Jul 2015 12:50:58 +0400
Subject: MDEV-4017 - GET_LOCK() with negative timeouts has strange behavior

GET_LOCK() silently accepted negative values and NULL for timeout.
Fixed GET_LOCK() to issue a warning and return NULL in such cases.
---
 .../extra/binlog_tests/mix_innodb_myisam_binlog.test   |  2 +-
 mysql-test/r/func_misc.result                          | 13 +++++++++++++
 .../suite/binlog/r/binlog_row_mix_innodb_myisam.result |  2 +-
 .../suite/binlog/r/binlog_stm_mix_innodb_myisam.result |  4 ++--
 mysql-test/t/func_misc.test                            |  5 +++++
 sql/item_func.cc                                       | 18 ++++++++++++++++++
 6 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test b/mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test
index b41bfeaba74..336b11113ec 100644
--- a/mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test
+++ b/mysql-test/extra/binlog_tests/mix_innodb_myisam_binlog.test
@@ -228,7 +228,7 @@ rollback;
 create table t0 (n int);
 insert t0 select * from t1;
 set autocommit=1;
-insert into t0 select GET_LOCK("lock1",null);
+insert into t0 select GET_LOCK("lock1",0);
 set autocommit=0;
 create table t2 (n int) engine=innodb;
 insert into t2 values (3); 
diff --git a/mysql-test/r/func_misc.result b/mysql-test/r/func_misc.result
index d5db28f04b8..d654dbccb0e 100644
--- a/mysql-test/r/func_misc.result
+++ b/mysql-test/r/func_misc.result
@@ -361,5 +361,18 @@ set optimizer_switch=@optimizer_switch_save;
 drop view  v_merge, vm;
 drop table t1,tv;
 #
+# MDEV-4017 - GET_LOCK() with negative timeouts has strange behavior
+#
+SELECT GET_LOCK('ul1', NULL);
+GET_LOCK('ul1', NULL)
+NULL
+Warnings:
+Warning	1411	Incorrect timeout value: 'NULL' for function get_lock
+SELECT GET_LOCK('ul1', -1);
+GET_LOCK('ul1', -1)
+NULL
+Warnings:
+Warning	1411	Incorrect timeout value: '-1' for function get_lock
+#
 # End of 5.5 tests
 #
diff --git a/mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result b/mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result
index ac36412c360..ed6e711af6b 100644
--- a/mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result
+++ b/mysql-test/suite/binlog/r/binlog_row_mix_innodb_myisam.result
@@ -258,7 +258,7 @@ Warning	1196	Some non-transactional changed tables couldn't be rolled back
 create table t0 (n int);
 insert t0 select * from t1;
 set autocommit=1;
-insert into t0 select GET_LOCK("lock1",null);
+insert into t0 select GET_LOCK("lock1",0);
 set autocommit=0;
 create table t2 (n int) engine=innodb;
 insert into t2 values (3);
diff --git a/mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result b/mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result
index c10aa7abd05..7309c611d29 100644
--- a/mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result
+++ b/mysql-test/suite/binlog/r/binlog_stm_mix_innodb_myisam.result
@@ -242,7 +242,7 @@ Warning	1196	Some non-transactional changed tables couldn't be rolled back
 create table t0 (n int);
 insert t0 select * from t1;
 set autocommit=1;
-insert into t0 select GET_LOCK("lock1",null);
+insert into t0 select GET_LOCK("lock1",0);
 Warnings:
 Note	1592	Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. Statement is unsafe because it uses a system function that may return a different value on the slave.
 set autocommit=0;
@@ -288,7 +288,7 @@ master-bin.000001	#	Query	#	#	BEGIN
 master-bin.000001	#	Query	#	#	use `test`; insert t0 select * from t1
 master-bin.000001	#	Query	#	#	COMMIT
 master-bin.000001	#	Query	#	#	BEGIN
-master-bin.000001	#	Query	#	#	use `test`; insert into t0 select GET_LOCK("lock1",null)
+master-bin.000001	#	Query	#	#	use `test`; insert into t0 select GET_LOCK("lock1",0)
 master-bin.000001	#	Query	#	#	COMMIT
 master-bin.000001	#	Query	#	#	use `test`; create table t2 (n int) engine=innodb
 master-bin.000001	#	Query	#	#	use `test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `t1`,`ti`
diff --git a/mysql-test/t/func_misc.test b/mysql-test/t/func_misc.test
index 24fe1ef7984..25d8cc1067a 100644
--- a/mysql-test/t/func_misc.test
+++ b/mysql-test/t/func_misc.test
@@ -391,6 +391,11 @@ set optimizer_switch=@optimizer_switch_save;
 drop view  v_merge, vm;
 drop table t1,tv;
 
+--echo #
+--echo # MDEV-4017 - GET_LOCK() with negative timeouts has strange behavior
+--echo #
+SELECT GET_LOCK('ul1', NULL);
+SELECT GET_LOCK('ul1', -1);
 
 --echo #
 --echo # End of 5.5 tests
diff --git a/sql/item_func.cc b/sql/item_func.cc
index ed08555133f..2f5130886e6 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -4184,7 +4184,25 @@ longlong Item_func_get_lock::val_int()
     it's not guaranteed to be same as on master.
   */
   if (thd->slave_thread)
+  {
+    null_value= 0;
     DBUG_RETURN(1);
+  }
+
+  if (args[1]->null_value ||
+      (!args[1]->unsigned_flag && ((longlong) timeout < 0)))
+  {
+    char buf[22];
+    if (args[1]->null_value)
+      strmov(buf, "NULL");
+    else
+      llstr(((longlong) timeout), buf);
+    push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+                        ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
+                        "timeout", buf, "get_lock");
+    null_value= 1;
+    DBUG_RETURN(0);
+  }
 
   mysql_mutex_lock(&LOCK_user_locks);
 
-- 
cgit v1.2.1


From e05cd97b8af6ebda0080eec40018207d0c78acbd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= <jan.lindstrom@mariadb.com>
Date: Wed, 29 Jul 2015 05:58:45 +0300
Subject: MDEV-8524: Improve error messaging when there is duplicate key or
 foreign key names

Added better error message that will be printed when foreign key
constraint name in create table is not unique in database.
---
 .../suite/innodb/r/innodb-fk-warnings.result       |  20 ++++
 mysql-test/suite/innodb/t/innodb-fk-warnings.test  |  29 +++++
 storage/innobase/dict/dict0crea.c                  | 117 ++++++++++++++++++++-
 storage/innobase/handler/ha_innodb.cc              |  26 +++++
 storage/innobase/include/ha_prototypes.h           |   9 ++
 storage/xtradb/dict/dict0crea.c                    | 117 ++++++++++++++++++++-
 storage/xtradb/handler/ha_innodb.cc                |  25 +++++
 storage/xtradb/include/ha_prototypes.h             |   9 ++
 8 files changed, 350 insertions(+), 2 deletions(-)
 create mode 100644 mysql-test/suite/innodb/r/innodb-fk-warnings.result
 create mode 100644 mysql-test/suite/innodb/t/innodb-fk-warnings.test

diff --git a/mysql-test/suite/innodb/r/innodb-fk-warnings.result b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
new file mode 100644
index 00000000000..c64cb3024b5
--- /dev/null
+++ b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
@@ -0,0 +1,20 @@
+CREATE TABLE t1 (
+id int(11) NOT NULL PRIMARY KEY,
+a int(11) NOT NULL,
+b int(11) NOT NULL,
+c int not null,
+CONSTRAINT test FOREIGN KEY (b) REFERENCES t1 (id)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+CREATE TABLE t2 (
+id int(11) NOT NULL PRIMARY KEY,
+a int(11) NOT NULL,
+b int(11) NOT NULL,
+c int not null,
+CONSTRAINT test FOREIGN KEY (b) REFERENCES t2 (id)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+ERROR HY000: Can't create table 'test.t2' (errno: 121)
+show warnings;
+Level	Code	Message
+Warning	121	InnoDB: foreign key constraint name `test/test` already exists on data dictionary. Foreign key constraint names need to be unique in database. Error in foreign key definition: CONSTRAINT `test` FOREIGN KEY (`b`) REFERENCES `test`.`t2` (`id`).
+Error	1005	Can't create table 'test.t2' (errno: 121)
+drop table t1;
diff --git a/mysql-test/suite/innodb/t/innodb-fk-warnings.test b/mysql-test/suite/innodb/t/innodb-fk-warnings.test
new file mode 100644
index 00000000000..e12a0ecf820
--- /dev/null
+++ b/mysql-test/suite/innodb/t/innodb-fk-warnings.test
@@ -0,0 +1,29 @@
+--source include/have_innodb.inc
+
+#
+# MDEV-8524: Improve error messaging when there is duplicate key or foreign key names
+#
+CREATE TABLE t1 (
+  id int(11) NOT NULL PRIMARY KEY,
+  a int(11) NOT NULL,
+  b int(11) NOT NULL,
+  c int not null,
+  CONSTRAINT test FOREIGN KEY (b) REFERENCES t1 (id)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+
+#
+# Below create table fails because constraint name test
+# is reserved for above table.
+#
+--error 1005
+CREATE TABLE t2 (
+  id int(11) NOT NULL PRIMARY KEY,
+  a int(11) NOT NULL,
+  b int(11) NOT NULL,
+  c int not null,
+  CONSTRAINT test FOREIGN KEY (b) REFERENCES t2 (id)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;
+
+show warnings;
+
+drop table t1;
diff --git a/storage/innobase/dict/dict0crea.c b/storage/innobase/dict/dict0crea.c
index ac8a1eac03c..7a52aff3ec3 100644
--- a/storage/innobase/dict/dict0crea.c
+++ b/storage/innobase/dict/dict0crea.c
@@ -1419,6 +1419,91 @@ dict_create_add_foreign_field_to_dictionary(
 		       table, foreign, trx));
 }
 
+/********************************************************************//**
+Construct foreign key constraint defintion from data dictionary information.
+*/
+static
+char*
+dict_foreign_def_get(
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx)	/*!< in: trx */
+{
+	char* fk_def = mem_heap_alloc(foreign->heap, 4*1024);
+	const char* tbname;
+	char tablebuf[MAX_TABLE_NAME_LEN + 1] = "";
+	int i;
+
+	tbname = dict_remove_db_name(foreign->id);
+	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+				tbname, strlen(tbname), trx->mysql_thd, FALSE);
+
+	sprintf(fk_def,
+		(char *)"CONSTRAINT %s FOREIGN KEY (", (char *)tablebuf);
+
+	for(i = 0; i < foreign->n_fields; i++) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->foreign_col_names[i],
+				strlen(foreign->foreign_col_names[i]),
+				trx->mysql_thd, FALSE);
+		strcat(fk_def, buf);
+		if (i < foreign->n_fields-1) {
+			strcat(fk_def, (char *)",");
+		}
+	}
+
+	strcat(fk_def,(char *)") REFERENCES ");
+
+	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	        foreign->referenced_table_name,
+		strlen(foreign->referenced_table_name),
+		trx->mysql_thd, TRUE);
+
+	strcat(fk_def, tablebuf);
+	strcat(fk_def, " (");
+
+	for(i = 0; i < foreign->n_fields; i++) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->referenced_col_names[i],
+				strlen(foreign->referenced_col_names[i]),
+				trx->mysql_thd, FALSE);
+		strcat(fk_def, buf);
+		if (i < foreign->n_fields-1) {
+			strcat(fk_def, (char *)",");
+		}
+	}
+	strcat(fk_def, (char *)")");
+
+	return fk_def;
+}
+
+/********************************************************************//**
+Convert foreign key column names from data dictionary to SQL-layer.
+*/
+static
+void
+dict_foreign_def_get_fields(
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx,	/*!< in: trx */
+	char**		field,  /*!< out: foreign column */
+	char**		field2, /*!< out: referenced column */
+	int		col_no) /*!< in: column number */
+{
+	*field = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+	*field2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+
+	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
+		foreign->foreign_col_names[col_no],
+		strlen(foreign->foreign_col_names[col_no]),
+		trx->mysql_thd, FALSE);
+
+	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
+		foreign->referenced_col_names[col_no],
+		strlen(foreign->referenced_col_names[col_no]),
+		trx->mysql_thd, FALSE);
+}
+
 /********************************************************************//**
 Add a single foreign key definition to the data dictionary tables in the
 database. We also generate names to constraints that were not named by the
@@ -1501,6 +1586,22 @@ dict_create_add_foreign_to_dictionary(
 
 	if (error != DB_SUCCESS) {
 
+		if (error == DB_DUPLICATE_KEY) {
+			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char*	fk_def;
+
+			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
+
+			fk_def = dict_foreign_def_get(foreign, trx);
+
+			ib_push_warning(trx, error, (const char *)"InnoDB: foreign key constraint name %s "
+				"already exists on data dictionary."
+				" Foreign key constraint names need to be unique in database."
+				" Error in foreign key definition: %s.",
+				buf, fk_def);
+		}
+
 		return(error);
 	}
 
@@ -1509,6 +1610,20 @@ dict_create_add_foreign_to_dictionary(
 			i, table, foreign, trx);
 
 		if (error != DB_SUCCESS) {
+			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char*	field=NULL;
+			char*	field2=NULL;
+			char*	fk_def;
+
+			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
+			fk_def = dict_foreign_def_get(foreign, trx);
+			dict_foreign_def_get_fields(foreign, trx, &field, &field2, i);
+
+			ib_push_warning(trx, error,
+				(const char *)"InnoDB: Error adding foreign  key constraint name %s fields %s or %s to the dictionary."
+				" Error in foreign key definition: %s.",
+				buf, i+1, fk_def);
 
 			return(error);
 		}
@@ -1593,7 +1708,7 @@ dict_create_add_foreigns_to_dictionary(
 	     foreign = UT_LIST_GET_NEXT(foreign_list, foreign)) {
 
 		error = dict_create_add_foreign_to_dictionary(&number, table,
-							      foreign, trx);
+			foreign, trx);
 
 		if (error != DB_SUCCESS) {
 
diff --git a/storage/innobase/handler/ha_innodb.cc b/storage/innobase/handler/ha_innodb.cc
index c97b5bfadc2..2bdbdf7a19f 100644
--- a/storage/innobase/handler/ha_innodb.cc
+++ b/storage/innobase/handler/ha_innodb.cc
@@ -12304,3 +12304,29 @@ ib_warn_row_too_big(const dict_table_t*	table)
 		" ROW_FORMAT=COMPRESSED ": ""
 		, prefix ? DICT_MAX_FIXED_COL_LEN : 0);
 }
+
+/********************************************************************//**
+Helper function to push warnings from InnoDB internals to SQL-layer. */
+extern "C" UNIV_INTERN
+void
+ib_push_warning(
+	trx_t*		trx,	/*!< in: trx */
+	ulint		error,	/*!< in: error code to push as warning */
+	const char	*format,/*!< in: warning message */
+	...)
+{
+	va_list args;
+	THD *thd = (THD *)trx->mysql_thd;
+	char *buf;
+#define MAX_BUF_SIZE 4*1024
+
+	va_start(args, format);
+	buf = (char *)my_malloc(MAX_BUF_SIZE, MYF(MY_WME));
+	vsprintf(buf,format, args);
+
+	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+		convert_error_code_to_mysql(error, 0, thd),
+		buf);
+	my_free(buf);
+	va_end(args);
+}
diff --git a/storage/innobase/include/ha_prototypes.h b/storage/innobase/include/ha_prototypes.h
index 3859b45e8d1..a69d3d126a0 100644
--- a/storage/innobase/include/ha_prototypes.h
+++ b/storage/innobase/include/ha_prototypes.h
@@ -326,5 +326,14 @@ innobase_convert_to_filename_charset(
 	const char*     from,   /* in: identifier to convert */
 	ulint           len);   /* in: length of 'to', in bytes */
 
+/********************************************************************//**
+Helper function to push warnings from InnoDB internals to SQL-layer. */
+UNIV_INTERN
+void
+ib_push_warning(
+	trx_t*		trx,	/*!< in: trx */
+	ulint		error,	/*!< in: error code to push as warning */
+	const char	*format,/*!< in: warning message */
+	...);
 
 #endif
diff --git a/storage/xtradb/dict/dict0crea.c b/storage/xtradb/dict/dict0crea.c
index c88979b20f9..71a00ca8d0f 100644
--- a/storage/xtradb/dict/dict0crea.c
+++ b/storage/xtradb/dict/dict0crea.c
@@ -1626,6 +1626,91 @@ dict_create_add_foreign_field_to_dictionary(
 		       table, foreign, trx));
 }
 
+/********************************************************************//**
+Construct foreign key constraint defintion from data dictionary information.
+*/
+static
+char*
+dict_foreign_def_get(
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx)	/*!< in: trx */
+{
+	char* fk_def = mem_heap_alloc(foreign->heap, 4*1024);
+	const char* tbname;
+	char tablebuf[MAX_TABLE_NAME_LEN + 1] = "";
+	int i;
+
+	tbname = dict_remove_db_name(foreign->id);
+	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+				tbname, strlen(tbname), trx->mysql_thd, FALSE);
+
+	sprintf(fk_def,
+		(char *)"CONSTRAINT %s FOREIGN KEY (", (char *)tablebuf);
+
+	for(i = 0; i < foreign->n_fields; i++) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->foreign_col_names[i],
+				strlen(foreign->foreign_col_names[i]),
+				trx->mysql_thd, FALSE);
+		strcat(fk_def, buf);
+		if (i < foreign->n_fields-1) {
+			strcat(fk_def, (char *)",");
+		}
+	}
+
+	strcat(fk_def,(char *)") REFERENCES ");
+
+	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	        foreign->referenced_table_name,
+		strlen(foreign->referenced_table_name),
+		trx->mysql_thd, TRUE);
+
+	strcat(fk_def, tablebuf);
+	strcat(fk_def, " (");
+
+	for(i = 0; i < foreign->n_fields; i++) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->referenced_col_names[i],
+				strlen(foreign->referenced_col_names[i]),
+				trx->mysql_thd, FALSE);
+		strcat(fk_def, buf);
+		if (i < foreign->n_fields-1) {
+			strcat(fk_def, (char *)",");
+		}
+	}
+	strcat(fk_def, (char *)")");
+
+	return fk_def;
+}
+
+/********************************************************************//**
+Convert foreign key column names from data dictionary to SQL-layer.
+*/
+static
+void
+dict_foreign_def_get_fields(
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx,	/*!< in: trx */
+	char**		field,  /*!< out: foreign column */
+	char**		field2, /*!< out: referenced column */
+	int		col_no) /*!< in: column number */
+{
+	*field = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+	*field2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+
+	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
+		foreign->foreign_col_names[col_no],
+		strlen(foreign->foreign_col_names[col_no]),
+		trx->mysql_thd, FALSE);
+
+	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
+		foreign->referenced_col_names[col_no],
+		strlen(foreign->referenced_col_names[col_no]),
+		trx->mysql_thd, FALSE);
+}
+
 /********************************************************************//**
 Add a single foreign key definition to the data dictionary tables in the
 database. We also generate names to constraints that were not named by the
@@ -1708,6 +1793,22 @@ dict_create_add_foreign_to_dictionary(
 
 	if (error != DB_SUCCESS) {
 
+		if (error == DB_DUPLICATE_KEY) {
+			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char*	fk_def;
+
+			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
+
+			fk_def = dict_foreign_def_get(foreign, trx);
+
+			ib_push_warning(trx, error, (const char *)"InnoDB: foreign key constraint name %s "
+				"already exists on data dictionary."
+				" Foreign key constraint names need to be unique in database."
+				" Error in foreign key definition: %s.",
+				buf, fk_def);
+		}
+
 		return(error);
 	}
 
@@ -1716,6 +1817,20 @@ dict_create_add_foreign_to_dictionary(
 			i, table, foreign, trx);
 
 		if (error != DB_SUCCESS) {
+			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char*	field=NULL;
+			char*	field2=NULL;
+			char*	fk_def;
+
+			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
+			fk_def = dict_foreign_def_get(foreign, trx);
+			dict_foreign_def_get_fields(foreign, trx, &field, &field2, i);
+
+			ib_push_warning(trx, error,
+				(const char *)"InnoDB: Error adding foreign  key constraint name %s fields %s or %s to the dictionary."
+				" Error in foreign key definition: %s.",
+				buf, i+1, fk_def);
 
 			return(error);
 		}
@@ -1800,7 +1915,7 @@ dict_create_add_foreigns_to_dictionary(
 	     foreign = UT_LIST_GET_NEXT(foreign_list, foreign)) {
 
 		error = dict_create_add_foreign_to_dictionary(&number, table,
-							      foreign, trx);
+			foreign, trx);
 
 		if (error != DB_SUCCESS) {
 
diff --git a/storage/xtradb/handler/ha_innodb.cc b/storage/xtradb/handler/ha_innodb.cc
index fa0081da436..6c4e9eedd7d 100644
--- a/storage/xtradb/handler/ha_innodb.cc
+++ b/storage/xtradb/handler/ha_innodb.cc
@@ -14107,3 +14107,28 @@ ha_innobase::idx_cond_push(
 	DBUG_RETURN(NULL);
 }
 
+/********************************************************************//**
+Helper function to push warnings from InnoDB internals to SQL-layer. */
+extern "C" UNIV_INTERN
+void
+ib_push_warning(
+	trx_t*		trx,	/*!< in: trx */
+	ulint		error,	/*!< in: error code to push as warning */
+	const char	*format,/*!< in: warning message */
+	...)
+{
+	va_list args;
+	THD *thd = (THD *)trx->mysql_thd;
+	char *buf;
+#define MAX_BUF_SIZE 4*1024
+
+	va_start(args, format);
+	buf = (char *)my_malloc(MAX_BUF_SIZE, MYF(MY_WME));
+	vsprintf(buf,format, args);
+
+	push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
+		convert_error_code_to_mysql(error, 0, thd),
+		buf);
+	my_free(buf);
+	va_end(args);
+}
diff --git a/storage/xtradb/include/ha_prototypes.h b/storage/xtradb/include/ha_prototypes.h
index ec2ba77f784..ad0abb88ff6 100644
--- a/storage/xtradb/include/ha_prototypes.h
+++ b/storage/xtradb/include/ha_prototypes.h
@@ -353,5 +353,14 @@ innobase_convert_to_filename_charset(
 	const char*     from,   /* in: identifier to convert */
 	ulint           len);   /* in: length of 'to', in bytes */
 
+/********************************************************************//**
+Helper function to push warnings from InnoDB internals to SQL-layer. */
+UNIV_INTERN
+void
+ib_push_warning(
+	trx_t*		trx,	/*!< in: trx */
+	ulint		error,	/*!< in: error code to push as warning */
+	const char	*format,/*!< in: warning message */
+	...);
 
 #endif
-- 
cgit v1.2.1


From fa765a45250176d1168ce5a61dee484c997604b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= <jan.lindstrom@mariadb.com>
Date: Fri, 31 Jul 2015 08:52:24 +0300
Subject: MDEV-6697: Improve foreign keys warnings/errors

There is several different ways to incorrectly define
foreign key constraint. In many cases earlier MariaDB
versions the error messages produced by these cases
are not very clear and helpful. This patch improves
the warning messages produced by foreign key parsing.
---
 .../suite/innodb/r/innodb-fk-warnings.result       |  87 +++-
 mysql-test/suite/innodb/r/innodb-fk.result         |   3 +
 mysql-test/suite/innodb/t/innodb-fk-warnings.test  | 101 ++++
 storage/innobase/dict/dict0crea.c                  |  27 +-
 storage/innobase/dict/dict0dict.c                  | 516 ++++++++++++++++++---
 storage/innobase/include/dict0crea.h               |  11 +
 storage/xtradb/dict/dict0crea.c                    |  27 +-
 storage/xtradb/dict/dict0dict.c                    | 516 ++++++++++++++++++---
 storage/xtradb/include/dict0crea.h                 |  11 +
 9 files changed, 1132 insertions(+), 167 deletions(-)

diff --git a/mysql-test/suite/innodb/r/innodb-fk-warnings.result b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
index c64cb3024b5..542fc972880 100644
--- a/mysql-test/suite/innodb/r/innodb-fk-warnings.result
+++ b/mysql-test/suite/innodb/r/innodb-fk-warnings.result
@@ -10,11 +10,96 @@ id int(11) NOT NULL PRIMARY KEY,
 a int(11) NOT NULL,
 b int(11) NOT NULL,
 c int not null,
+CONSTRAINT mytest FOREIGN KEY (c) REFERENCES t1(id),
 CONSTRAINT test FOREIGN KEY (b) REFERENCES t2 (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
 ERROR HY000: Can't create table 'test.t2' (errno: 121)
 show warnings;
 Level	Code	Message
-Warning	121	InnoDB: foreign key constraint name `test/test` already exists on data dictionary. Foreign key constraint names need to be unique in database. Error in foreign key definition: CONSTRAINT `test` FOREIGN KEY (`b`) REFERENCES `test`.`t2` (`id`).
+Warning	121	Create or Alter table `test`.`t2` with foreign key constraint failed. Foreign key constraint `test/test` already exists on data dictionary. Foreign key constraint names need to be unique in database. Error in foreign key definition: CONSTRAINT `test` FOREIGN KEY (`b`) REFERENCES `test`.`t2` (`id`).
 Error	1005	Can't create table 'test.t2' (errno: 121)
 drop table t1;
+create table t1(a int) engine=innodb;
+create table t2(a int, constraint a foreign key a (a) references t1(a)) engine=innodb;
+ERROR HY000: Can't create table 'test.t2' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Create  table '`test`.`t2`' with foreign key constraint failed. There is no index in the referenced table where the referenced columns appear as the first columns. Error close to  foreign key a (a) references t1(a)) engine=innodb.
+Error	1005	Can't create table 'test.t2' (errno: 150)
+drop table t1;
+create table t1(a int not null primary key, b int) engine=innodb;
+create table t2(a int, b int, constraint a foreign key a (a) references t1(a),
+constraint a foreign key a (a) references t1(b)) engine=innodb;
+ERROR HY000: Can't create table 'test.t2' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Create  table '`test`.`t2`' with foreign key constraint failed. There is no index in the referenced table where the referenced columns appear as the first columns. Error close to  foreign key a (a) references t1(b)) engine=innodb.
+Error	1005	Can't create table 'test.t2' (errno: 150)
+create table t2(a int, b int, constraint a foreign key a (a) references t1(a)) engine=innodb;
+alter table t2 add constraint b foreign key (b) references t2(b);
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table '`test`.`t2`' with foreign key constraint failed. There is no index in the referenced table where the referenced columns appear as the first columns. Error close to  foreign key (b) references t2(b).
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+drop table t2, t1;
+create table t1 (f1 integer primary key) engine=innodb;
+alter table t1 add constraint c1 foreign key (f1) references t11(f1);
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table `test`.`t1` with foreign key constraint failed. Referenced table `test`.`t11` not found in the data dictionary close to  foreign key (f1) references t11(f1).
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+drop table t1;
+create temporary table t1(a int not null primary key, b int, key(b)) engine=innodb;
+create temporary table t2(a int, foreign key(a) references t1(a)) engine=innodb;
+ERROR HY000: Can't create table 'test.t2' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Create  table `mysqld.1`.`t2` with foreign key constraint failed. Referenced table `mysqld.1`.`t1` not found in the data dictionary close to foreign key(a) references t1(a)) engine=innodb.
+Error	1005	Can't create table 'test.t2' (errno: 150)
+alter table t1 add foreign key(b) references t1(a);
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table `mysqld.1`.`t1` with foreign key constraint failed. Referenced table `mysqld.1`.`t1` not found in the data dictionary close to foreign key(b) references t1(a).
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+drop table t1;
+create table t1(a int not null primary key, b int, key(b)) engine=innodb;
+alter table t1 add foreign key(a,b) references t1(a);
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table `test`.`t1` with foreign key constraint failed. Foreign key constraint parse error in foreign key(a,b) references t1(a) close to ). Too few referenced columns, you have 1 when you should have 2.
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+drop table t1;
+create table t1(a int not null primary key, b int, key(b)) engine=innodb;
+alter table t1 add foreign key(a) references t1(a,b);
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table `test`.`t1` with foreign key constraint failed. Foreign key constraint parse error in foreign key(a) references t1(a,b) close to ). Too few referenced columns, you have 2 when you should have 1.
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+drop table t1;
+create table t1 (f1 integer not null primary key) engine=innodb;
+alter table t1 add constraint c1 foreign key (f1) references t1(f1) on update set null;
+ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Alter  table `test`.`t1` with foreign key constraint failed. You have defined a SET NULL condition but column f1 is defined as NOT NULL in  foreign key (f1) references t1(f1) on update set null close to  on update set null.
+Error	1005	Can't create table '#sql-temporary' (errno: 150)
+create table t2(a int not null, foreign key(a) references t1(f1) on delete set null) engine=innodb;
+ERROR HY000: Can't create table 'test.t2' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Create  table `test`.`t2` with foreign key constraint failed. You have defined a SET NULL condition but column a is defined as NOT NULL in foreign key(a) references t1(f1) on delete set null) engine=innodb close to  on delete set null) engine=innodb.
+Error	1005	Can't create table 'test.t2' (errno: 150)
+drop table t1;
+create table t1 (id int not null primary key, f1 int, f2 int, key(f1)) engine=innodb;
+create table t2(a char(20), key(a), foreign key(a) references t1(f1)) engine=innodb;
+ERROR HY000: Can't create table 'test.t2' (errno: 150)
+show warnings;
+Level	Code	Message
+Warning	150	Create  table `test`.`t2` with foreign key constraint failed. Field type or character set for column a does not mach referenced column f1 close to foreign key(a) references t1(f1)) engine=innodb
+Error	1005	Can't create table 'test.t2' (errno: 150)
+drop table t1;
diff --git a/mysql-test/suite/innodb/r/innodb-fk.result b/mysql-test/suite/innodb/r/innodb-fk.result
index 3c557534dbd..2b53bc21b31 100644
--- a/mysql-test/suite/innodb/r/innodb-fk.result
+++ b/mysql-test/suite/innodb/r/innodb-fk.result
@@ -50,6 +50,8 @@ CONSTRAINT fk3 FOREIGN KEY (f3) REFERENCES t3 (id) ON DELETE CASCADE
 ERROR HY000: Can't create table 'test.t2' (errno: 150)
 show warnings;
 Level	Code	Message
+Warning	150	Create  table `test`.`t2` with foreign key constraint failed. Referenced table `test`.`t3` not found in the data dictionary close to  FOREIGN KEY (f3) REFERENCES t3 (id) ON DELETE CASCADE
+) ENGINE=InnoDB.
 Error	1005	Can't create table 'test.t2' (errno: 150)
 CREATE TABLE t2 (
 id int(11) NOT NULL AUTO_INCREMENT,
@@ -62,6 +64,7 @@ ALTER TABLE t2 ADD CONSTRAINT fk3 FOREIGN KEY (f3) REFERENCES t3 (id) ON DELETE
 ERROR HY000: Can't create table '#sql-temporary' (errno: 150)
 show warnings;
 Level	Code	Message
+Warning	150	Alter  table `test`.`t2` with foreign key constraint failed. Referenced table `test`.`t3` not found in the data dictionary close to  FOREIGN KEY (f3) REFERENCES t3 (id) ON DELETE CASCADE.
 Error	1005	Can't create table '#sql-temporary' (errno: 150)
 drop table t2;
 drop table t1;
diff --git a/mysql-test/suite/innodb/t/innodb-fk-warnings.test b/mysql-test/suite/innodb/t/innodb-fk-warnings.test
index e12a0ecf820..fe92f1345f4 100644
--- a/mysql-test/suite/innodb/t/innodb-fk-warnings.test
+++ b/mysql-test/suite/innodb/t/innodb-fk-warnings.test
@@ -21,9 +21,110 @@ CREATE TABLE t2 (
   a int(11) NOT NULL,
   b int(11) NOT NULL,
   c int not null,
+  CONSTRAINT mytest FOREIGN KEY (c) REFERENCES t1(id),
   CONSTRAINT test FOREIGN KEY (b) REFERENCES t2 (id)
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1;
 
 show warnings;
 
 drop table t1;
+
+#
+# MDEV-6697: Improve foreign keys warnings/errors
+#
+
+#
+# No index for referenced columns
+#
+create table t1(a int) engine=innodb;
+--error 1005
+create table t2(a int, constraint a foreign key a (a) references t1(a)) engine=innodb;
+show warnings;
+drop table t1;
+
+create table t1(a int not null primary key, b int) engine=innodb;
+--error 1005
+create table t2(a int, b int, constraint a foreign key a (a) references t1(a),
+constraint a foreign key a (a) references t1(b)) engine=innodb;
+show warnings;
+create table t2(a int, b int, constraint a foreign key a (a) references t1(a)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t2 add constraint b foreign key (b) references t2(b);
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t2, t1;
+
+#
+# Referenced table does not exists
+#
+
+create table t1 (f1 integer primary key) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t1 add constraint c1 foreign key (f1) references t11(f1);
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
+
+#
+# Foreign key on temporal tables
+#
+
+create temporary table t1(a int not null primary key, b int, key(b)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+create temporary table t2(a int, foreign key(a) references t1(a)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t1 add foreign key(b) references t1(a);
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
+
+#
+# Column numbers do not match
+#
+create table t1(a int not null primary key, b int, key(b)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t1 add foreign key(a,b) references t1(a);
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
+create table t1(a int not null primary key, b int, key(b)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t1 add foreign key(a) references t1(a,b);
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
+
+#
+# ON UPDATE/DELETE SET NULL on NOT NULL column
+#
+create table t1 (f1 integer not null primary key) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+alter table t1 add constraint c1 foreign key (f1) references t1(f1) on update set null;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+create table t2(a int not null, foreign key(a) references t1(f1) on delete set null) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
+
+#
+# Incorrect types
+#
+create table t1 (id int not null primary key, f1 int, f2 int, key(f1)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+--error 1005
+create table t2(a char(20), key(a), foreign key(a) references t1(f1)) engine=innodb;
+--replace_regex /'[^']*test.#sql-[0-9a-f_]*'/'#sql-temporary'/
+show warnings;
+drop table t1;
diff --git a/storage/innobase/dict/dict0crea.c b/storage/innobase/dict/dict0crea.c
index 7a52aff3ec3..87fbd462697 100644
--- a/storage/innobase/dict/dict0crea.c
+++ b/storage/innobase/dict/dict0crea.c
@@ -1422,9 +1422,10 @@ dict_create_add_foreign_field_to_dictionary(
 /********************************************************************//**
 Construct foreign key constraint defintion from data dictionary information.
 */
-static
+UNIV_INTERN
 char*
 dict_foreign_def_get(
+/*=================*/
 	dict_foreign_t*	foreign,/*!< in: foreign */
 	trx_t*		trx)	/*!< in: trx */
 {
@@ -1484,6 +1485,7 @@ Convert foreign key column names from data dictionary to SQL-layer.
 static
 void
 dict_foreign_def_get_fields(
+/*========================*/
 	dict_foreign_t*	foreign,/*!< in: foreign */
 	trx_t*		trx,	/*!< in: trx */
 	char**		field,  /*!< out: foreign column */
@@ -1588,18 +1590,25 @@ dict_create_add_foreign_to_dictionary(
 
 		if (error == DB_DUPLICATE_KEY) {
 			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
 			char*	fk_def;
 
+			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
+				table->name, strlen(table->name),
+				trx->mysql_thd, TRUE);
+
 			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
 
 			fk_def = dict_foreign_def_get(foreign, trx);
 
-			ib_push_warning(trx, error, (const char *)"InnoDB: foreign key constraint name %s "
-				"already exists on data dictionary."
+			ib_push_warning(trx, error,
+				"Create or Alter table %s with foreign key constraint"
+				" failed. Foreign key constraint %s"
+				" already exists on data dictionary."
 				" Foreign key constraint names need to be unique in database."
 				" Error in foreign key definition: %s.",
-				buf, fk_def);
+				tablename, buf, fk_def);
 		}
 
 		return(error);
@@ -1611,19 +1620,25 @@ dict_create_add_foreign_to_dictionary(
 
 		if (error != DB_SUCCESS) {
 			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
 			char*	field=NULL;
 			char*	field2=NULL;
 			char*	fk_def;
 
+			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
+				table->name, strlen(table->name),
+				trx->mysql_thd, TRUE);
 			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
 			fk_def = dict_foreign_def_get(foreign, trx);
 			dict_foreign_def_get_fields(foreign, trx, &field, &field2, i);
 
 			ib_push_warning(trx, error,
-				(const char *)"InnoDB: Error adding foreign  key constraint name %s fields %s or %s to the dictionary."
+				"Create or Alter table %s with foreign key constraint"
+				" failed. Error adding foreign  key constraint name %s"
+				" fields %s or %s to the dictionary."
 				" Error in foreign key definition: %s.",
-				buf, i+1, fk_def);
+				tablename, buf, i+1, fk_def);
 
 			return(error);
 		}
diff --git a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
index cbb17fc5a6f..4211d864d7c 100644
--- a/storage/innobase/dict/dict0dict.c
+++ b/storage/innobase/dict/dict0dict.c
@@ -2614,6 +2614,11 @@ dict_foreign_find(
 	DBUG_RETURN(NULL);
 }
 
+#define  DB_FOREIGN_KEY_IS_PREFIX_INDEX 200
+#define  DB_FOREIGN_KEY_COL_NOT_NULL    201
+#define  DB_FOREIGN_KEY_COLS_NOT_EQUAL  202
+#define  DB_FOREIGN_KEY_INDEX_NOT_FOUND 203
+
 /*********************************************************************//**
 Tries to find an index whose first fields are the columns in the array,
 in the same order and is not marked for deletion and is not the same
@@ -2631,12 +2636,21 @@ dict_foreign_find_index(
 	ibool		check_charsets,
 				/*!< in: whether to check charsets.
 				only has an effect if types_idx != NULL */
-	ulint		check_null)
+	ulint		check_null,
 				/*!< in: nonzero if none of the columns must
 				be declared NOT NULL */
+	ulint*		error,	/*!< out: error code */
+	ulint*		err_col_no,
+				/*!< out: column number where error happened */
+	dict_index_t**	err_index)
+			        /*!< out: index where error happened */
 {
 	dict_index_t*	index;
 
+	if (error) {
+		*error = DB_FOREIGN_KEY_INDEX_NOT_FOUND;
+	}
+
 	index = dict_table_get_first_index(table);
 
 	while (index != NULL) {
@@ -2662,6 +2676,12 @@ dict_foreign_find_index(
 					/* We do not accept column prefix
 					indexes here */
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_IS_PREFIX_INDEX;
+						*err_col_no = i;
+						*err_index = index;
+					}
+
 					break;
 				}
 
@@ -2673,6 +2693,11 @@ dict_foreign_find_index(
 				if (check_null
 				    && (field->col->prtype & DATA_NOT_NULL)) {
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_COL_NOT_NULL;
+						*err_col_no = i;
+						*err_index = index;
+					}
 					return(NULL);
 				}
 
@@ -2682,6 +2707,12 @@ dict_foreign_find_index(
 								   i),
 					    check_charsets)) {
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_COLS_NOT_EQUAL;
+						*err_col_no = i;
+						*err_index = index;
+					}
+
 					break;
 				}
 			}
@@ -2689,6 +2720,10 @@ dict_foreign_find_index(
 			if (i == n_cols) {
 				/* We found a matching index */
 
+				if (error) {
+					*error = DB_SUCCESS;
+				}
+
 				return(index);
 			}
 		}
@@ -2720,7 +2755,7 @@ dict_foreign_find_equiv_index(
 		       foreign->foreign_table,
 		       foreign->foreign_col_names, foreign->n_fields,
 		       foreign->foreign_index, TRUE, /* check types */
-		       FALSE/* allow columns to be NULL */));
+		       FALSE/* allow columns to be NULL */, NULL, NULL, NULL));
 }
 
 #endif /* !UNIV_HOTBACKUP */
@@ -2883,11 +2918,15 @@ dict_foreign_add_to_cache(
 	}
 
 	if (for_in_cache->referenced_table == NULL && ref_table) {
+		ulint index_error;
+		ulint err_col;
+		dict_index_t *err_index=NULL;
+
 		index = dict_foreign_find_index(
 			ref_table,
 			for_in_cache->referenced_col_names,
 			for_in_cache->n_fields, for_in_cache->foreign_index,
-			check_charsets, FALSE);
+			check_charsets, FALSE, &index_error, &err_col, &err_index);
 
 		if (index == NULL
 		    && !(ignore_err & DICT_ERR_IGNORE_FK_NOKEY)) {
@@ -2919,6 +2958,9 @@ dict_foreign_add_to_cache(
 	}
 
 	if (for_in_cache->foreign_table == NULL && for_table) {
+		ulint index_error;
+		ulint err_col;
+		dict_index_t* err_index=NULL;
 
 		index = dict_foreign_find_index(
 			for_table,
@@ -2927,7 +2969,8 @@ dict_foreign_add_to_cache(
 			for_in_cache->referenced_index, check_charsets,
 			for_in_cache->type
 			& (DICT_FOREIGN_ON_DELETE_SET_NULL
-			   | DICT_FOREIGN_ON_UPDATE_SET_NULL));
+				| DICT_FOREIGN_ON_UPDATE_SET_NULL),
+			&index_error, &err_col, &err_index);
 
 		if (index == NULL
 		    && !(ignore_err & DICT_ERR_IGNORE_FK_NOKEY)) {
@@ -3538,6 +3581,8 @@ static
 void
 dict_foreign_report_syntax_err(
 /*===========================*/
+	const char*     fmt,		/*!< in: syntax err msg */
+	const char*	oper,		/*!< in: operation */
 	const char*	name,		/*!< in: table name */
 	const char*	start_of_latest_foreign,
 					/*!< in: start of the foreign key clause
@@ -3548,11 +3593,101 @@ dict_foreign_report_syntax_err(
 
 	mutex_enter(&dict_foreign_err_mutex);
 	dict_foreign_error_report_low(ef, name);
-	fprintf(ef, "%s:\nSyntax error close to:\n%s\n",
-		start_of_latest_foreign, ptr);
+	fprintf(ef, fmt, oper, name, start_of_latest_foreign, ptr);
 	mutex_exit(&dict_foreign_err_mutex);
 }
 
+/*********************************************************************//**
+Push warning message to SQL-layer based on foreign key constraint
+index match error. */
+static
+void
+dict_foreign_push_index_error(
+/*==========================*/
+	trx_t*		trx,		/*!< in: trx */
+	const char*	operation,	/*!< in: operation create or alter
+					*/
+	const char*	create_name,	/*!< in: table name in create or
+					alter table */
+	const char*	latest_foreign,	/*!< in: start of latest foreign key
+					constraint name */
+	const char**	columns,	/*!< in: foreign key columns */
+	ulint		index_error,	/*!< in: error code */
+	ulint		err_col,	/*!< in: column where error happened
+					*/
+	dict_index_t*	err_index,	/*!< in: index where error happened
+					*/
+	dict_table_t*	table,		/*!< in: table */
+	FILE*		ef)		/*!< in: output stream */
+{
+	switch (index_error) {
+	case DB_FOREIGN_KEY_INDEX_NOT_FOUND: {
+		fprintf(ef,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is no index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.\n",
+			operation, create_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is no index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.",
+			operation, create_name, latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_IS_PREFIX_INDEX: {
+		fprintf(ef,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is only prefix index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.\n",
+			operation, create_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is only prefix index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.",
+			operation, create_name, latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_COL_NOT_NULL: {
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. You have defined a SET NULL condition but "
+			"field %s on index is defined as NOT NULL close to %s\n",
+			operation, create_name, columns[err_col], latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. You have defined a SET NULL condition but "
+			"field %s on index is defined as NOT NULL close to %s",
+			operation, create_name, columns[err_col], latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_COLS_NOT_EQUAL: {
+		dict_field_t*	field;
+		const char*	col_name;
+		field = dict_index_get_nth_field(err_index, err_col);
+
+		col_name = dict_table_get_col_name(
+			table, dict_col_get_no(field->col));
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Field type or character set for column %s "
+			"does not mach referenced column %s close to %s\n",
+			operation, create_name, columns[err_col], col_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Field type or character set for column %s "
+			"does not mach referenced column %s close to %s",
+			operation, create_name, columns[err_col], col_name, latest_foreign);
+		break;
+	}
+	default:
+		ut_error;
+	}
+}
+
 /*********************************************************************//**
 Scans a table create SQL string and adds to the data dictionary the foreign
 key constraints declared in the string. This function should be called after
@@ -3581,15 +3716,20 @@ dict_create_foreign_constraints_low(
 				DB_CANNOT_ADD_CONSTRAINT if any foreign
 				keys are found. */
 {
-	dict_table_t*	table;
-	dict_table_t*	referenced_table;
-	dict_table_t*	table_to_alter;
+	dict_table_t*	table			= NULL;
+	dict_table_t*	referenced_table	= NULL;
+	dict_table_t*	table_to_alter		= NULL;
+	dict_table_t*	table_to_create		= NULL;
 	ulint		highest_id_so_far	= 0;
-	dict_index_t*	index;
-	dict_foreign_t*	foreign;
+	dict_index_t*	index			= NULL;
+	dict_foreign_t*	foreign			= NULL;
 	const char*	ptr			= sql_string;
 	const char*	start_of_latest_foreign	= sql_string;
+	const char*	start_of_latest_set     = NULL;
 	FILE*		ef			= dict_foreign_err_file;
+	ulint		index_error		= DB_SUCCESS;
+	dict_index_t*	err_index		= NULL;
+	ulint		err_col;
 	const char*	constraint_name;
 	ibool		success;
 	ulint		error;
@@ -3602,29 +3742,64 @@ dict_create_foreign_constraints_low(
 	ulint		n_on_updates;
 	const dict_col_t*columns[500];
 	const char*	column_names[500];
+	const char*	ref_column_names[500];
 	const char*	referenced_table_name;
+	const char*	create_table_name;
+	const char*	orig;
+	const char	create_name[MAX_TABLE_NAME_LEN + 1];
+	const char	operation[8];
 
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 
 	table = dict_table_get_low(name, DICT_ERR_IGNORE_NONE);
+	/* First check if we are actually doing an ALTER TABLE, and in that
+	case look for the table being altered */
+	ptr = dict_accept(cs, ptr, "ALTER", &success);
+
+	strcpy((char *)operation, success ? "Alter " : "Create ");
+
+	if (!success) {
+		orig = ptr;
+		ptr = dict_scan_to(ptr, "CREATE");
+		ptr = dict_scan_to(ptr, "TABLE");
+		ptr = dict_accept(cs, ptr, "TABLE", &success);
+
+		if (success) {
+			ptr = dict_scan_table_name(cs, ptr, &table_to_create, name,
+					&success, heap, &create_table_name);
+		}
+
+		if (success) {
+			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				create_table_name, strlen(create_table_name),
+				trx->mysql_thd, TRUE);
+			ptr = orig;
+		} else {
+			ptr = orig;
+			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				name, strlen(name), trx->mysql_thd, TRUE);
+		}
+
+		goto loop;
+	}
 
 	if (table == NULL) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef,
-			"Cannot find the table in the internal"
-			" data dictionary of InnoDB.\n"
-			"Create table statement:\n%s\n", sql_string);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef, "%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.\n",
+			operation, create_name, create_name, start_of_latest_foreign);
 		mutex_exit(&dict_foreign_err_mutex);
-
+		ib_push_warning(trx, DB_ERROR,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.",
+			operation, create_name, create_name, start_of_latest_foreign);
 		return(DB_ERROR);
 	}
 
-	/* First check if we are actually doing an ALTER TABLE, and in that
-	case look for the table being altered */
-
-	ptr = dict_accept(cs, ptr, "ALTER", &success);
-
+	/* If not alter table jump to loop */
 	if (!success) {
 
 		goto loop;
@@ -3639,13 +3814,35 @@ dict_create_foreign_constraints_low(
 
 	/* We are doing an ALTER TABLE: scan the table name we are altering */
 
+	orig = ptr;
 	ptr = dict_scan_table_name(cs, ptr, &table_to_alter, name,
 				   &success, heap, &referenced_table_name);
+
+	if (table_to_alter) {
+		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+			table_to_alter->name, strlen(table_to_alter->name),
+			trx->mysql_thd, TRUE);
+	} else {
+		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+			referenced_table_name, strlen(referenced_table_name),
+			trx->mysql_thd, TRUE);
+	}
+
 	if (!success) {
-		fprintf(stderr,
-			"InnoDB: Error: could not find"
-			" the table being ALTERED in:\n%s\n",
-			sql_string);
+		mutex_enter(&dict_foreign_err_mutex);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.\n",
+			operation, create_name, create_name, orig);
+		mutex_exit(&dict_foreign_err_mutex);
+
+		ib_push_warning(trx, DB_ERROR,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.",
+			operation, create_name, create_name, orig);
 
 		return(DB_ERROR);
 	}
@@ -3711,7 +3908,19 @@ loop:
 		if so, immediately reject the command if the table is a
 		temporary one. For now, this kludge will work. */
 		if (reject_fks && (UT_LIST_GET_LEN(table->foreign_list) > 0)) {
+			mutex_enter(&dict_foreign_err_mutex);
+			dict_foreign_error_report_low(ef, create_name);
+			fprintf(ef, "%s table %s with foreign key constraint"
+				" failed. Temporary tables can't have foreign key constraints."
+				" Error close to %s.\n",
+				operation, create_name, start_of_latest_foreign);
+			mutex_exit(&dict_foreign_err_mutex);
 
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Temporary tables can't have foreign key constraints."
+				" Error close to %s.",
+				operation, create_name, start_of_latest_foreign);
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 
@@ -3747,11 +3956,21 @@ loop:
 	if (!success) {
 		/* MySQL allows also an index id before the '('; we
 		skip it */
+		orig = ptr;
 		ptr = dict_skip_word(cs, ptr, &success);
 
 		if (!success) {
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, orig);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, orig);
 
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
@@ -3771,15 +3990,26 @@ loop:
 	/* Scan the columns in the first list */
 col_loop1:
 	ut_a(i < (sizeof column_names) / sizeof *column_names);
+	orig = ptr;
 	ptr = dict_scan_col(cs, ptr, &success, table, columns + i,
 			    heap, column_names + i);
 	if (!success) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve column name close to:\n%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3791,11 +4021,22 @@ col_loop1:
 		goto col_loop1;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, ")", &success);
 
 	if (!success) {
 		dict_foreign_report_syntax_err(
-			name, start_of_latest_foreign, ptr);
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3803,27 +4044,41 @@ col_loop1:
 	as the first fields and in the right order */
 
 	index = dict_foreign_find_index(table, column_names, i,
-					NULL, TRUE, FALSE);
+		NULL, TRUE, FALSE, &index_error, &err_col, &err_index);
 
 	if (!index) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
+		dict_foreign_error_report_low(ef, create_name);
 		fputs("There is no index in table ", ef);
-		ut_print_name(ef, NULL, TRUE, name);
+		ut_print_name(ef, NULL, TRUE, create_name);
 		fprintf(ef, " where the columns appear\n"
 			"as the first columns. Constraint:\n%s\n"
 			"See " REFMAN "innodb-foreign-key-constraints.html\n"
 			"for correct foreign key definition.\n",
 			start_of_latest_foreign);
-		mutex_exit(&dict_foreign_err_mutex);
 
-		return(DB_CHILD_NO_INDEX);
+		dict_foreign_push_index_error(trx, operation, create_name, start_of_latest_foreign,
+			column_names, index_error, err_col, err_index, table, ef);
+
+		mutex_exit(&dict_foreign_err_mutex);
+		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
+
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "REFERENCES", &success);
 
 	if (!success || !my_isspace(cs, *ptr)) {
 		dict_foreign_report_syntax_err(
-			name, start_of_latest_foreign, ptr);
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3872,24 +4127,48 @@ col_loop1:
 	checking of foreign key constraints! */
 
 	if (!success || (!referenced_table && trx->check_foreigns)) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+			referenced_table_name, strlen(referenced_table_name),
+			trx->mysql_thd, TRUE);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
+			"close to %s.",
+			operation, create_name, buf, start_of_latest_foreign);
+
 		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve table name close to:\n"
-			"%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
+			"close to %s.\n",
+			operation, create_name, buf, start_of_latest_foreign);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "(", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3897,20 +4176,29 @@ col_loop1:
 	i = 0;
 
 col_loop2:
+	orig = ptr;
 	ptr = dict_scan_col(cs, ptr, &success, referenced_table, columns + i,
-			    heap, column_names + i);
+			    heap, ref_column_names + i);
 	i++;
 
 	if (!success) {
 		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve column name close to:\n"
-			"%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3920,13 +4208,23 @@ col_loop2:
 		goto col_loop2;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, ")", &success);
 
 	if (!success || foreign->n_fields != i) {
 		dict_foreign_free(foreign);
 
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s. Too few referenced columns.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s. Too few referenced columns, you have %d when you should have %d.",
+			operation, create_name, start_of_latest_foreign, orig, i, foreign->n_fields);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3936,6 +4234,7 @@ col_loop2:
 scan_on_conditions:
 	/* Loop here as long as we can find ON ... conditions */
 
+	start_of_latest_set = ptr;
 	ptr = dict_accept(cs, ptr, "ON", &success);
 
 	if (!success) {
@@ -3946,13 +4245,24 @@ scan_on_conditions:
 	ptr = dict_accept(cs, ptr, "DELETE", &success);
 
 	if (!success) {
+		orig = ptr;
 		ptr = dict_accept(cs, ptr, "UPDATE", &success);
 
 		if (!success) {
 			dict_foreign_free(foreign);
 
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 
@@ -3984,12 +4294,22 @@ scan_on_conditions:
 	ptr = dict_accept(cs, ptr, "NO", &success);
 
 	if (success) {
+		orig = ptr;
 		ptr = dict_accept(cs, ptr, "ACTION", &success);
 
 		if (!success) {
 			dict_foreign_free(foreign);
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
 
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
@@ -4003,42 +4323,73 @@ scan_on_conditions:
 		goto scan_on_conditions;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "SET", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "NULL", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
 	for (j = 0; j < foreign->n_fields; j++) {
 		if ((dict_index_get_nth_col(foreign->foreign_index, j)->prtype)
 		    & DATA_NOT_NULL) {
+			const dict_col_t*	col
+				= dict_index_get_nth_col(foreign->foreign_index, j);
+			const char* col_name = dict_table_get_col_name(foreign->foreign_index->table,
+				dict_col_get_no(col));
 
 			/* It is not sensible to define SET NULL
 			if the column is not allowed to be NULL! */
 
-			dict_foreign_free(foreign);
-
 			mutex_enter(&dict_foreign_err_mutex);
-			dict_foreign_error_report_low(ef, name);
-			fprintf(ef, "%s:\n"
-				"You have defined a SET NULL condition"
-				" though some of the\n"
-				"columns are defined as NOT NULL.\n",
-				start_of_latest_foreign);
+			dict_foreign_error_report_low(ef, create_name);
+			fprintf(ef,
+				"%s table %s with foreign key constraint"
+				" failed. You have defined a SET NULL condition but column %s is defined as NOT NULL"
+				" in %s close to %s.\n",
+				operation, create_name, col_name, start_of_latest_foreign, start_of_latest_set);
 			mutex_exit(&dict_foreign_err_mutex);
 
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. You have defined a SET NULL condition but column %s is defined as NOT NULL"
+				" in %s close to %s.",
+				operation, create_name, col_name, start_of_latest_foreign, start_of_latest_set);
+
+			dict_foreign_free(foreign);
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 	}
@@ -4055,16 +4406,22 @@ try_find_index:
 	if (n_on_deletes > 1 || n_on_updates > 1) {
 		/* It is an error to define more than 1 action */
 
-		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\n"
-			"You have twice an ON DELETE clause"
-			" or twice an ON UPDATE clause.\n",
-			start_of_latest_foreign);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. You have more than one on delete or on update clause"
+			" in %s close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. You have more than one on delete or on update clause"
+			" in %s close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+		dict_foreign_free(foreign);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4074,13 +4431,13 @@ try_find_index:
 
 	if (referenced_table) {
 		index = dict_foreign_find_index(referenced_table,
-						column_names, i,
-						foreign->foreign_index,
-						TRUE, FALSE);
+					ref_column_names, i,
+					foreign->foreign_index,
+					TRUE, FALSE, &index_error, &err_col, &err_index);
 		if (!index) {
 			dict_foreign_free(foreign);
 			mutex_enter(&dict_foreign_err_mutex);
-			dict_foreign_error_report_low(ef, name);
+			dict_foreign_error_report_low(ef, create_name);
 			fprintf(ef, "%s:\n"
 				"Cannot find an index in the"
 				" referenced table where the\n"
@@ -4098,9 +4455,13 @@ try_find_index:
 				"innodb-foreign-key-constraints.html\n"
 				"for correct foreign key definition.\n",
 				start_of_latest_foreign);
+
+			dict_foreign_push_index_error(trx, operation, create_name, start_of_latest_foreign,
+				column_names, index_error, err_col, err_index, referenced_table, ef);
+
 			mutex_exit(&dict_foreign_err_mutex);
 
-			return(DB_PARENT_NO_INDEX);
+			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 	} else {
 		ut_a(trx->check_foreigns == FALSE);
@@ -4118,7 +4479,7 @@ try_find_index:
 						       i * sizeof(void*));
 	for (i = 0; i < foreign->n_fields; i++) {
 		foreign->referenced_col_names[i]
-			= mem_heap_strdup(foreign->heap, column_names[i]);
+			= mem_heap_strdup(foreign->heap, ref_column_names[i]);
 	}
 
 	/* We found an ok constraint definition: add to the lists */
@@ -5251,7 +5612,8 @@ dict_table_replace_index_in_foreign_list(
 				foreign->referenced_table,
 				foreign->referenced_col_names,
 				foreign->n_fields, index,
-				/*check_charsets=*/TRUE, /*check_null=*/FALSE);
+				/*check_charsets=*/TRUE, /*check_null=*/FALSE,
+				NULL, NULL, NULL);
 			ut_ad(new_index || !trx->check_foreigns);
 			ut_ad(!new_index || new_index->table == index->table);
 
diff --git a/storage/innobase/include/dict0crea.h b/storage/innobase/include/dict0crea.h
index 9faf580b0cc..a58bcb181aa 100644
--- a/storage/innobase/include/dict0crea.h
+++ b/storage/innobase/include/dict0crea.h
@@ -106,6 +106,17 @@ UNIV_INTERN
 ulint
 dict_create_or_check_foreign_constraint_tables(void);
 /*================================================*/
+
+/********************************************************************//**
+Construct foreign key constraint defintion from data dictionary information.
+*/
+UNIV_INTERN
+char*
+dict_foreign_def_get(
+/*=================*/
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx);	/*!< in: trx */
+
 /********************************************************************//**
 Adds foreign key definitions to data dictionary tables in the database. We
 look at table->foreign_list, and also generate names to constraints that were
diff --git a/storage/xtradb/dict/dict0crea.c b/storage/xtradb/dict/dict0crea.c
index 71a00ca8d0f..64a6d706557 100644
--- a/storage/xtradb/dict/dict0crea.c
+++ b/storage/xtradb/dict/dict0crea.c
@@ -1629,9 +1629,10 @@ dict_create_add_foreign_field_to_dictionary(
 /********************************************************************//**
 Construct foreign key constraint defintion from data dictionary information.
 */
-static
+UNIV_INTERN
 char*
 dict_foreign_def_get(
+/*=================*/
 	dict_foreign_t*	foreign,/*!< in: foreign */
 	trx_t*		trx)	/*!< in: trx */
 {
@@ -1691,6 +1692,7 @@ Convert foreign key column names from data dictionary to SQL-layer.
 static
 void
 dict_foreign_def_get_fields(
+/*========================*/
 	dict_foreign_t*	foreign,/*!< in: foreign */
 	trx_t*		trx,	/*!< in: trx */
 	char**		field,  /*!< out: foreign column */
@@ -1795,18 +1797,25 @@ dict_create_add_foreign_to_dictionary(
 
 		if (error == DB_DUPLICATE_KEY) {
 			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
 			char*	fk_def;
 
+			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
+				table->name, strlen(table->name),
+				trx->mysql_thd, TRUE);
+
 			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
 
 			fk_def = dict_foreign_def_get(foreign, trx);
 
-			ib_push_warning(trx, error, (const char *)"InnoDB: foreign key constraint name %s "
-				"already exists on data dictionary."
+			ib_push_warning(trx, error,
+				"Create or Alter table %s with foreign key constraint"
+				" failed. Foreign key constraint %s"
+				" already exists on data dictionary."
 				" Foreign key constraint names need to be unique in database."
 				" Error in foreign key definition: %s.",
-				buf, fk_def);
+				tablename, buf, fk_def);
 		}
 
 		return(error);
@@ -1818,19 +1827,25 @@ dict_create_add_foreign_to_dictionary(
 
 		if (error != DB_SUCCESS) {
 			char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+			char	tablename[MAX_TABLE_NAME_LEN + 1] = "";
 			char*	field=NULL;
 			char*	field2=NULL;
 			char*	fk_def;
 
+			innobase_convert_name(tablename, MAX_TABLE_NAME_LEN,
+				table->name, strlen(table->name),
+				trx->mysql_thd, TRUE);
 			innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->id, strlen(foreign->id), trx->mysql_thd, FALSE);
 			fk_def = dict_foreign_def_get(foreign, trx);
 			dict_foreign_def_get_fields(foreign, trx, &field, &field2, i);
 
 			ib_push_warning(trx, error,
-				(const char *)"InnoDB: Error adding foreign  key constraint name %s fields %s or %s to the dictionary."
+				"Create or Alter table %s with foreign key constraint"
+				" failed. Error adding foreign  key constraint name %s"
+				" fields %s or %s to the dictionary."
 				" Error in foreign key definition: %s.",
-				buf, i+1, fk_def);
+				tablename, buf, i+1, fk_def);
 
 			return(error);
 		}
diff --git a/storage/xtradb/dict/dict0dict.c b/storage/xtradb/dict/dict0dict.c
index bd0fdf6e9b9..754ddfa752d 100644
--- a/storage/xtradb/dict/dict0dict.c
+++ b/storage/xtradb/dict/dict0dict.c
@@ -2747,6 +2747,11 @@ dict_foreign_find(
 	DBUG_RETURN(NULL);
 }
 
+#define  DB_FOREIGN_KEY_IS_PREFIX_INDEX 200
+#define  DB_FOREIGN_KEY_COL_NOT_NULL    201
+#define  DB_FOREIGN_KEY_COLS_NOT_EQUAL  202
+#define  DB_FOREIGN_KEY_INDEX_NOT_FOUND 203
+
 /*********************************************************************//**
 Tries to find an index whose first fields are the columns in the array,
 in the same order and is not marked for deletion and is not the same
@@ -2764,12 +2769,21 @@ dict_foreign_find_index(
 	ibool		check_charsets,
 				/*!< in: whether to check charsets.
 				only has an effect if types_idx != NULL */
-	ulint		check_null)
+	ulint		check_null,
 				/*!< in: nonzero if none of the columns must
 				be declared NOT NULL */
+	ulint*		error,	/*!< out: error code */
+	ulint*		err_col_no,
+				/*!< out: column number where error happened */
+	dict_index_t**	err_index)
+			        /*!< out: index where error happened */
 {
 	dict_index_t*	index;
 
+	if (error) {
+		*error = DB_FOREIGN_KEY_INDEX_NOT_FOUND;
+	}
+
 	index = dict_table_get_first_index(table);
 
 	while (index != NULL) {
@@ -2795,6 +2809,12 @@ dict_foreign_find_index(
 					/* We do not accept column prefix
 					indexes here */
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_IS_PREFIX_INDEX;
+						*err_col_no = i;
+						*err_index = index;
+					}
+
 					break;
 				}
 
@@ -2806,6 +2826,11 @@ dict_foreign_find_index(
 				if (check_null
 				    && (field->col->prtype & DATA_NOT_NULL)) {
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_COL_NOT_NULL;
+						*err_col_no = i;
+						*err_index = index;
+					}
 					return(NULL);
 				}
 
@@ -2815,6 +2840,12 @@ dict_foreign_find_index(
 								   i),
 					    check_charsets)) {
 
+					if (error && err_col_no && err_index) {
+						*error = DB_FOREIGN_KEY_COLS_NOT_EQUAL;
+						*err_col_no = i;
+						*err_index = index;
+					}
+
 					break;
 				}
 			}
@@ -2822,6 +2853,10 @@ dict_foreign_find_index(
 			if (i == n_cols) {
 				/* We found a matching index */
 
+				if (error) {
+					*error = DB_SUCCESS;
+				}
+
 				return(index);
 			}
 		}
@@ -2853,7 +2888,7 @@ dict_foreign_find_equiv_index(
 		       foreign->foreign_table,
 		       foreign->foreign_col_names, foreign->n_fields,
 		       foreign->foreign_index, TRUE, /* check types */
-		       FALSE/* allow columns to be NULL */));
+		       FALSE/* allow columns to be NULL */, NULL, NULL, NULL));
 }
 
 #endif /* !UNIV_HOTBACKUP */
@@ -3016,11 +3051,15 @@ dict_foreign_add_to_cache(
 	}
 
 	if (for_in_cache->referenced_table == NULL && ref_table) {
+		ulint index_error;
+		ulint err_col;
+		dict_index_t *err_index=NULL;
+
 		index = dict_foreign_find_index(
 			ref_table,
 			for_in_cache->referenced_col_names,
 			for_in_cache->n_fields, for_in_cache->foreign_index,
-			check_charsets, FALSE);
+			check_charsets, FALSE, &index_error, &err_col, &err_index);
 
 		if (index == NULL
 		    && !(ignore_err & DICT_ERR_IGNORE_FK_NOKEY)) {
@@ -3052,6 +3091,9 @@ dict_foreign_add_to_cache(
 	}
 
 	if (for_in_cache->foreign_table == NULL && for_table) {
+		ulint index_error;
+		ulint err_col;
+		dict_index_t* err_index=NULL;
 
 		index = dict_foreign_find_index(
 			for_table,
@@ -3060,7 +3102,8 @@ dict_foreign_add_to_cache(
 			for_in_cache->referenced_index, check_charsets,
 			for_in_cache->type
 			& (DICT_FOREIGN_ON_DELETE_SET_NULL
-			   | DICT_FOREIGN_ON_UPDATE_SET_NULL));
+				| DICT_FOREIGN_ON_UPDATE_SET_NULL),
+			&index_error, &err_col, &err_index);
 
 		if (index == NULL
 		    && !(ignore_err & DICT_ERR_IGNORE_FK_NOKEY)) {
@@ -3671,6 +3714,8 @@ static
 void
 dict_foreign_report_syntax_err(
 /*===========================*/
+	const char*     fmt,		/*!< in: syntax err msg */
+	const char*	oper,		/*!< in: operation */
 	const char*	name,		/*!< in: table name */
 	const char*	start_of_latest_foreign,
 					/*!< in: start of the foreign key clause
@@ -3681,11 +3726,101 @@ dict_foreign_report_syntax_err(
 
 	mutex_enter(&dict_foreign_err_mutex);
 	dict_foreign_error_report_low(ef, name);
-	fprintf(ef, "%s:\nSyntax error close to:\n%s\n",
-		start_of_latest_foreign, ptr);
+	fprintf(ef, fmt, oper, name, start_of_latest_foreign, ptr);
 	mutex_exit(&dict_foreign_err_mutex);
 }
 
+/*********************************************************************//**
+Push warning message to SQL-layer based on foreign key constraint
+index match error. */
+static
+void
+dict_foreign_push_index_error(
+/*==========================*/
+	trx_t*		trx,		/*!< in: trx */
+	const char*	operation,	/*!< in: operation create or alter
+					*/
+	const char*	create_name,	/*!< in: table name in create or
+					alter table */
+	const char*	latest_foreign,	/*!< in: start of latest foreign key
+					constraint name */
+	const char**	columns,	/*!< in: foreign key columns */
+	ulint		index_error,	/*!< in: error code */
+	ulint		err_col,	/*!< in: column where error happened
+					*/
+	dict_index_t*	err_index,	/*!< in: index where error happened
+					*/
+	dict_table_t*	table,		/*!< in: table */
+	FILE*		ef)		/*!< in: output stream */
+{
+	switch (index_error) {
+	case DB_FOREIGN_KEY_INDEX_NOT_FOUND: {
+		fprintf(ef,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is no index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.\n",
+			operation, create_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is no index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.",
+			operation, create_name, latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_IS_PREFIX_INDEX: {
+		fprintf(ef,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is only prefix index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.\n",
+			operation, create_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table '%s' with foreign key constraint"
+			" failed. There is only prefix index in the referenced"
+			" table where the referenced columns appear"
+			" as the first columns. Error close to %s.",
+			operation, create_name, latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_COL_NOT_NULL: {
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. You have defined a SET NULL condition but "
+			"field %s on index is defined as NOT NULL close to %s\n",
+			operation, create_name, columns[err_col], latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. You have defined a SET NULL condition but "
+			"field %s on index is defined as NOT NULL close to %s",
+			operation, create_name, columns[err_col], latest_foreign);
+		break;
+	}
+	case DB_FOREIGN_KEY_COLS_NOT_EQUAL: {
+		dict_field_t*	field;
+		const char*	col_name;
+		field = dict_index_get_nth_field(err_index, err_col);
+
+		col_name = dict_table_get_col_name(
+			table, dict_col_get_no(field->col));
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Field type or character set for column %s "
+			"does not mach referenced column %s close to %s\n",
+			operation, create_name, columns[err_col], col_name, latest_foreign);
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Field type or character set for column %s "
+			"does not mach referenced column %s close to %s",
+			operation, create_name, columns[err_col], col_name, latest_foreign);
+		break;
+	}
+	default:
+		ut_error;
+	}
+}
+
 /*********************************************************************//**
 Scans a table create SQL string and adds to the data dictionary the foreign
 key constraints declared in the string. This function should be called after
@@ -3714,15 +3849,20 @@ dict_create_foreign_constraints_low(
 				DB_CANNOT_ADD_CONSTRAINT if any foreign
 				keys are found. */
 {
-	dict_table_t*	table;
-	dict_table_t*	referenced_table;
-	dict_table_t*	table_to_alter;
+	dict_table_t*	table			= NULL;
+	dict_table_t*	referenced_table	= NULL;
+	dict_table_t*	table_to_alter		= NULL;
+	dict_table_t*	table_to_create		= NULL;
 	ulint		highest_id_so_far	= 0;
-	dict_index_t*	index;
-	dict_foreign_t*	foreign;
+	dict_index_t*	index			= NULL;
+	dict_foreign_t*	foreign			= NULL;
 	const char*	ptr			= sql_string;
 	const char*	start_of_latest_foreign	= sql_string;
+	const char*	start_of_latest_set     = NULL;
 	FILE*		ef			= dict_foreign_err_file;
+	ulint		index_error		= DB_SUCCESS;
+	dict_index_t*	err_index		= NULL;
+	ulint		err_col;
 	const char*	constraint_name;
 	ibool		success;
 	ulint		error;
@@ -3735,29 +3875,64 @@ dict_create_foreign_constraints_low(
 	ulint		n_on_updates;
 	const dict_col_t*columns[500];
 	const char*	column_names[500];
+	const char*	ref_column_names[500];
 	const char*	referenced_table_name;
+	const char*	create_table_name;
+	const char*	orig;
+	const char	create_name[MAX_TABLE_NAME_LEN + 1];
+	const char	operation[8];
 
 	ut_ad(mutex_own(&(dict_sys->mutex)));
 
 	table = dict_table_get_low(name, DICT_ERR_IGNORE_NONE);
+	/* First check if we are actually doing an ALTER TABLE, and in that
+	case look for the table being altered */
+	ptr = dict_accept(cs, ptr, "ALTER", &success);
+
+	strcpy((char *)operation, success ? "Alter " : "Create ");
+
+	if (!success) {
+		orig = ptr;
+		ptr = dict_scan_to(ptr, "CREATE");
+		ptr = dict_scan_to(ptr, "TABLE");
+		ptr = dict_accept(cs, ptr, "TABLE", &success);
+
+		if (success) {
+			ptr = dict_scan_table_name(cs, ptr, &table_to_create, name,
+					&success, heap, &create_table_name);
+		}
+
+		if (success) {
+			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				create_table_name, strlen(create_table_name),
+				trx->mysql_thd, TRUE);
+			ptr = orig;
+		} else {
+			ptr = orig;
+			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				name, strlen(name), trx->mysql_thd, TRUE);
+		}
+
+		goto loop;
+	}
 
 	if (table == NULL) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef,
-			"Cannot find the table in the internal"
-			" data dictionary of InnoDB.\n"
-			"Create table statement:\n%s\n", sql_string);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef, "%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.\n",
+			operation, create_name, create_name, start_of_latest_foreign);
 		mutex_exit(&dict_foreign_err_mutex);
-
+		ib_push_warning(trx, DB_ERROR,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.",
+			operation, create_name, create_name, start_of_latest_foreign);
 		return(DB_ERROR);
 	}
 
-	/* First check if we are actually doing an ALTER TABLE, and in that
-	case look for the table being altered */
-
-	ptr = dict_accept(cs, ptr, "ALTER", &success);
-
+	/* If not alter table jump to loop */
 	if (!success) {
 
 		goto loop;
@@ -3772,13 +3947,35 @@ dict_create_foreign_constraints_low(
 
 	/* We are doing an ALTER TABLE: scan the table name we are altering */
 
+	orig = ptr;
 	ptr = dict_scan_table_name(cs, ptr, &table_to_alter, name,
 				   &success, heap, &referenced_table_name);
+
+	if (table_to_alter) {
+		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+			table_to_alter->name, strlen(table_to_alter->name),
+			trx->mysql_thd, TRUE);
+	} else {
+		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+			referenced_table_name, strlen(referenced_table_name),
+			trx->mysql_thd, TRUE);
+	}
+
 	if (!success) {
-		fprintf(stderr,
-			"InnoDB: Error: could not find"
-			" the table being ALTERED in:\n%s\n",
-			sql_string);
+		mutex_enter(&dict_foreign_err_mutex);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.\n",
+			operation, create_name, create_name, orig);
+		mutex_exit(&dict_foreign_err_mutex);
+
+		ib_push_warning(trx, DB_ERROR,
+			"%s table %s with foreign key constraint"
+			" failed. Table %s not found from data dictionary."
+			" Error close to %s.",
+			operation, create_name, create_name, orig);
 
 		return(DB_ERROR);
 	}
@@ -3844,7 +4041,19 @@ loop:
 		if so, immediately reject the command if the table is a
 		temporary one. For now, this kludge will work. */
 		if (reject_fks && (UT_LIST_GET_LEN(table->foreign_list) > 0)) {
+			mutex_enter(&dict_foreign_err_mutex);
+			dict_foreign_error_report_low(ef, create_name);
+			fprintf(ef, "%s table %s with foreign key constraint"
+				" failed. Temporary tables can't have foreign key constraints."
+				" Error close to %s.\n",
+				operation, create_name, start_of_latest_foreign);
+			mutex_exit(&dict_foreign_err_mutex);
 
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Temporary tables can't have foreign key constraints."
+				" Error close to %s.",
+				operation, create_name, start_of_latest_foreign);
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 
@@ -3880,11 +4089,21 @@ loop:
 	if (!success) {
 		/* MySQL allows also an index id before the '('; we
 		skip it */
+		orig = ptr;
 		ptr = dict_skip_word(cs, ptr, &success);
 
 		if (!success) {
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, orig);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, orig);
 
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
@@ -3904,15 +4123,26 @@ loop:
 	/* Scan the columns in the first list */
 col_loop1:
 	ut_a(i < (sizeof column_names) / sizeof *column_names);
+	orig = ptr;
 	ptr = dict_scan_col(cs, ptr, &success, table, columns + i,
 			    heap, column_names + i);
 	if (!success) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve column name close to:\n%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3924,11 +4154,22 @@ col_loop1:
 		goto col_loop1;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, ")", &success);
 
 	if (!success) {
 		dict_foreign_report_syntax_err(
-			name, start_of_latest_foreign, ptr);
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -3936,27 +4177,41 @@ col_loop1:
 	as the first fields and in the right order */
 
 	index = dict_foreign_find_index(table, column_names, i,
-					NULL, TRUE, FALSE);
+		NULL, TRUE, FALSE, &index_error, &err_col, &err_index);
 
 	if (!index) {
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
+		dict_foreign_error_report_low(ef, create_name);
 		fputs("There is no index in table ", ef);
-		ut_print_name(ef, NULL, TRUE, name);
+		ut_print_name(ef, NULL, TRUE, create_name);
 		fprintf(ef, " where the columns appear\n"
 			"as the first columns. Constraint:\n%s\n"
 			"See " REFMAN "innodb-foreign-key-constraints.html\n"
 			"for correct foreign key definition.\n",
 			start_of_latest_foreign);
-		mutex_exit(&dict_foreign_err_mutex);
 
-		return(DB_CHILD_NO_INDEX);
+		dict_foreign_push_index_error(trx, operation, create_name, start_of_latest_foreign,
+			column_names, index_error, err_col, err_index, table, ef);
+
+		mutex_exit(&dict_foreign_err_mutex);
+		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
+
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "REFERENCES", &success);
 
 	if (!success || !my_isspace(cs, *ptr)) {
 		dict_foreign_report_syntax_err(
-			name, start_of_latest_foreign, ptr);
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4005,24 +4260,48 @@ col_loop1:
 	checking of foreign key constraints! */
 
 	if (!success || (!referenced_table && trx->check_foreigns)) {
+		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+
+		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+			referenced_table_name, strlen(referenced_table_name),
+			trx->mysql_thd, TRUE);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
+			"close to %s.",
+			operation, create_name, buf, start_of_latest_foreign);
+
 		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve table name close to:\n"
-			"%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
+			"close to %s.\n",
+			operation, create_name, buf, start_of_latest_foreign);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "(", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4030,20 +4309,29 @@ col_loop1:
 	i = 0;
 
 col_loop2:
+	orig = ptr;
 	ptr = dict_scan_col(cs, ptr, &success, referenced_table, columns + i,
-			    heap, column_names + i);
+			    heap, ref_column_names + i);
 	i++;
 
 	if (!success) {
 		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\nCannot resolve column name close to:\n"
-			"%s\n",
-			start_of_latest_foreign, ptr);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, orig);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4053,13 +4341,23 @@ col_loop2:
 		goto col_loop2;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, ")", &success);
 
 	if (!success || foreign->n_fields != i) {
 		dict_foreign_free(foreign);
 
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s. Too few referenced columns\n",
+			operation, create_name, start_of_latest_foreign, orig);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s. Too few referenced columns, you have %d when you should have %d.",
+			operation, create_name, start_of_latest_foreign, orig, i, foreign->n_fields);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4069,6 +4367,7 @@ col_loop2:
 scan_on_conditions:
 	/* Loop here as long as we can find ON ... conditions */
 
+	start_of_latest_set = ptr;
 	ptr = dict_accept(cs, ptr, "ON", &success);
 
 	if (!success) {
@@ -4079,13 +4378,24 @@ scan_on_conditions:
 	ptr = dict_accept(cs, ptr, "DELETE", &success);
 
 	if (!success) {
+		orig = ptr;
 		ptr = dict_accept(cs, ptr, "UPDATE", &success);
 
 		if (!success) {
 			dict_foreign_free(foreign);
 
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 
@@ -4117,12 +4427,22 @@ scan_on_conditions:
 	ptr = dict_accept(cs, ptr, "NO", &success);
 
 	if (success) {
+		orig = ptr;
 		ptr = dict_accept(cs, ptr, "ACTION", &success);
 
 		if (!success) {
 			dict_foreign_free(foreign);
 			dict_foreign_report_syntax_err(
-				name, start_of_latest_foreign, ptr);
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.\n",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. Foreign key constraint parse error in %s"
+				" close to %s.",
+				operation, create_name, start_of_latest_foreign, start_of_latest_set);
 
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
@@ -4136,42 +4456,73 @@ scan_on_conditions:
 		goto scan_on_conditions;
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "SET", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
+	orig = ptr;
 	ptr = dict_accept(cs, ptr, "NULL", &success);
 
 	if (!success) {
 		dict_foreign_free(foreign);
-		dict_foreign_report_syntax_err(name, start_of_latest_foreign,
-					       ptr);
+		dict_foreign_report_syntax_err(
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. Foreign key constraint parse error in %s"
+			" close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
 	for (j = 0; j < foreign->n_fields; j++) {
 		if ((dict_index_get_nth_col(foreign->foreign_index, j)->prtype)
 		    & DATA_NOT_NULL) {
+			const dict_col_t*	col
+				= dict_index_get_nth_col(foreign->foreign_index, j);
+			const char* col_name = dict_table_get_col_name(foreign->foreign_index->table,
+				dict_col_get_no(col));
 
 			/* It is not sensible to define SET NULL
 			if the column is not allowed to be NULL! */
 
-			dict_foreign_free(foreign);
-
 			mutex_enter(&dict_foreign_err_mutex);
-			dict_foreign_error_report_low(ef, name);
-			fprintf(ef, "%s:\n"
-				"You have defined a SET NULL condition"
-				" though some of the\n"
-				"columns are defined as NOT NULL.\n",
-				start_of_latest_foreign);
+			dict_foreign_error_report_low(ef, create_name);
+			fprintf(ef,
+				"%s table %s with foreign key constraint"
+				" failed. You have defined a SET NULL condition but column %s is defined as NOT NULL"
+				" in %s close to %s.\n",
+				operation, create_name, col_name, start_of_latest_foreign, start_of_latest_set);
 			mutex_exit(&dict_foreign_err_mutex);
 
+
+			ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+				"%s table %s with foreign key constraint"
+				" failed. You have defined a SET NULL condition but column %s is defined as NOT NULL"
+				" in %s close to %s.",
+				operation, create_name, col_name, start_of_latest_foreign, start_of_latest_set);
+
+			dict_foreign_free(foreign);
 			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 	}
@@ -4188,16 +4539,22 @@ try_find_index:
 	if (n_on_deletes > 1 || n_on_updates > 1) {
 		/* It is an error to define more than 1 action */
 
-		dict_foreign_free(foreign);
 
 		mutex_enter(&dict_foreign_err_mutex);
-		dict_foreign_error_report_low(ef, name);
-		fprintf(ef, "%s:\n"
-			"You have twice an ON DELETE clause"
-			" or twice an ON UPDATE clause.\n",
-			start_of_latest_foreign);
+		dict_foreign_error_report_low(ef, create_name);
+		fprintf(ef,
+			"%s table %s with foreign key constraint"
+			" failed. You have more than one on delete or on update clause"
+			" in %s close to %s.\n",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
 		mutex_exit(&dict_foreign_err_mutex);
 
+		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
+			"%s table %s with foreign key constraint"
+			" failed. You have more than one on delete or on update clause"
+			" in %s close to %s.",
+			operation, create_name, start_of_latest_foreign, start_of_latest_set);
+		dict_foreign_free(foreign);
 		return(DB_CANNOT_ADD_CONSTRAINT);
 	}
 
@@ -4207,13 +4564,13 @@ try_find_index:
 
 	if (referenced_table) {
 		index = dict_foreign_find_index(referenced_table,
-						column_names, i,
-						foreign->foreign_index,
-						TRUE, FALSE);
+					ref_column_names, i,
+					foreign->foreign_index,
+					TRUE, FALSE, &index_error, &err_col, &err_index);
 		if (!index) {
 			dict_foreign_free(foreign);
 			mutex_enter(&dict_foreign_err_mutex);
-			dict_foreign_error_report_low(ef, name);
+			dict_foreign_error_report_low(ef, create_name);
 			fprintf(ef, "%s:\n"
 				"Cannot find an index in the"
 				" referenced table where the\n"
@@ -4231,9 +4588,13 @@ try_find_index:
 				"innodb-foreign-key-constraints.html\n"
 				"for correct foreign key definition.\n",
 				start_of_latest_foreign);
+
+			dict_foreign_push_index_error(trx, operation, create_name, start_of_latest_foreign,
+				column_names, index_error, err_col, err_index, referenced_table, ef);
+
 			mutex_exit(&dict_foreign_err_mutex);
 
-			return(DB_PARENT_NO_INDEX);
+			return(DB_CANNOT_ADD_CONSTRAINT);
 		}
 	} else {
 		ut_a(trx->check_foreigns == FALSE);
@@ -4251,7 +4612,7 @@ try_find_index:
 						       i * sizeof(void*));
 	for (i = 0; i < foreign->n_fields; i++) {
 		foreign->referenced_col_names[i]
-			= mem_heap_strdup(foreign->heap, column_names[i]);
+			= mem_heap_strdup(foreign->heap, ref_column_names[i]);
 	}
 
 	/* We found an ok constraint definition: add to the lists */
@@ -5796,7 +6157,8 @@ dict_table_replace_index_in_foreign_list(
 				foreign->referenced_table,
 				foreign->referenced_col_names,
 				foreign->n_fields, index,
-				/*check_charsets=*/TRUE, /*check_null=*/FALSE);
+				/*check_charsets=*/TRUE, /*check_null=*/FALSE,
+				NULL, NULL, NULL);
 			ut_ad(new_index || !trx->check_foreigns);
 			ut_ad(!new_index || new_index->table == index->table);
 
diff --git a/storage/xtradb/include/dict0crea.h b/storage/xtradb/include/dict0crea.h
index 762ab54a353..c67910f0d55 100644
--- a/storage/xtradb/include/dict0crea.h
+++ b/storage/xtradb/include/dict0crea.h
@@ -121,6 +121,17 @@ UNIV_INTERN
 ulint
 dict_create_or_check_foreign_constraint_tables(void);
 /*================================================*/
+
+/********************************************************************//**
+Construct foreign key constraint defintion from data dictionary information.
+*/
+UNIV_INTERN
+char*
+dict_foreign_def_get(
+/*=================*/
+	dict_foreign_t*	foreign,/*!< in: foreign */
+	trx_t*		trx);	/*!< in: trx */
+
 /********************************************************************//**
 Adds foreign key definitions to data dictionary tables in the database. We
 look at table->foreign_list, and also generate names to constraints that were
-- 
cgit v1.2.1


From 1ad294e06430d9fa2dd7e4dd84ffd7909aff0ca5 Mon Sep 17 00:00:00 2001
From: Sergey Vojtovich <svoj@mariadb.org>
Date: Thu, 30 Jul 2015 18:51:44 +0400
Subject: MDEV-7821 - Server crashes in Item_func_group_concat::fix_fields on
 2nd             execution of PS

GROUP_CONCAT() with ORDER BY column position may crash server on PS reexecution.

The problem was that arguments array of GROUP_CONCAT() was adjusted to point to
temporary elements (resolved ORDER BY fields) during first execution.

This patch expands rev. 08763096cb to restore original arguments array as well.
---
 mysql-test/r/func_gconcat.result | 16 ++++++++++++++++
 mysql-test/t/func_gconcat.test   | 11 +++++++++++
 sql/item_sum.cc                  |  3 +++
 3 files changed, 30 insertions(+)

diff --git a/mysql-test/r/func_gconcat.result b/mysql-test/r/func_gconcat.result
index f12a0c1127a..0bc31a5e85b 100644
--- a/mysql-test/r/func_gconcat.result
+++ b/mysql-test/r/func_gconcat.result
@@ -1103,3 +1103,19 @@ ORDER BY field;
 field
 c,c
 drop table t3, t2, t1;
+#
+# MDEV-7821 - Server crashes in Item_func_group_concat::fix_fields on 2nd
+#             execution of PS
+#
+CREATE TABLE t1(a INT);
+INSERT INTO t1 VALUES(1),(2);
+PREPARE stmt FROM "SELECT GROUP_CONCAT(t1a.a ORDER BY 1, t1a.a=0) FROM t1 AS t1a, t1 AS t1b GROUP BY t1a.a";
+EXECUTE stmt;
+GROUP_CONCAT(t1a.a ORDER BY 1, t1a.a=0)
+1,1
+2,2
+EXECUTE stmt;
+GROUP_CONCAT(t1a.a ORDER BY 1, t1a.a=0)
+1,1
+2,2
+DROP TABLE t1;
diff --git a/mysql-test/t/func_gconcat.test b/mysql-test/t/func_gconcat.test
index 42a30760a86..5550eebf1a3 100644
--- a/mysql-test/t/func_gconcat.test
+++ b/mysql-test/t/func_gconcat.test
@@ -821,3 +821,14 @@ FROM ( SELECT * FROM t2 ) AS sq2, t3
 ORDER BY field;
 
 drop table t3, t2, t1;
+
+--echo #
+--echo # MDEV-7821 - Server crashes in Item_func_group_concat::fix_fields on 2nd
+--echo #             execution of PS
+--echo #
+CREATE TABLE t1(a INT);
+INSERT INTO t1 VALUES(1),(2);
+PREPARE stmt FROM "SELECT GROUP_CONCAT(t1a.a ORDER BY 1, t1a.a=0) FROM t1 AS t1a, t1 AS t1b GROUP BY t1a.a";
+EXECUTE stmt;
+EXECUTE stmt;
+DROP TABLE t1;
diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index d8970ca26b5..a24307b131b 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -3300,6 +3300,8 @@ void Item_func_group_concat::cleanup()
     from Item_func_group_concat::setup() to point to runtime
     created objects, we need to reset them back to the original
     arguments of the function.
+
+    The very same applies to args array.
   */
   ORDER **order_ptr= order;
   for (uint i= 0; i < arg_count_order; i++)
@@ -3307,6 +3309,7 @@ void Item_func_group_concat::cleanup()
     (*order_ptr)->item= &args[arg_count_field + i];
     order_ptr++;
   }
+  memcpy(args, orig_args, sizeof(Item *) * arg_count);
   DBUG_VOID_RETURN;
 }
 
-- 
cgit v1.2.1


From 360e597c3c9f6adbe113f80d3d9cd9afc3b81f89 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jan=20Lindstr=C3=B6m?= <jan.lindstrom@mariadb.com>
Date: Fri, 31 Jul 2015 12:06:29 +0300
Subject: Make sure name buffer has string end marker on correct place.

---
 storage/innobase/dict/dict0crea.c | 47 ++++++++++++++++++++++++---------------
 storage/innobase/dict/dict0dict.c | 41 +++++++++++++++++++++-------------
 storage/xtradb/dict/dict0crea.c   | 47 ++++++++++++++++++++++++---------------
 storage/xtradb/dict/dict0dict.c   | 41 +++++++++++++++++++++-------------
 4 files changed, 110 insertions(+), 66 deletions(-)

diff --git a/storage/innobase/dict/dict0crea.c b/storage/innobase/dict/dict0crea.c
index 87fbd462697..dcbca492b08 100644
--- a/storage/innobase/dict/dict0crea.c
+++ b/storage/innobase/dict/dict0crea.c
@@ -1433,10 +1433,12 @@ dict_foreign_def_get(
 	const char* tbname;
 	char tablebuf[MAX_TABLE_NAME_LEN + 1] = "";
 	int i;
+	char* bufend;
 
 	tbname = dict_remove_db_name(foreign->id);
-	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
 				tbname, strlen(tbname), trx->mysql_thd, FALSE);
+	tablebuf[bufend - tablebuf] = '\0';
 
 	sprintf(fk_def,
 		(char *)"CONSTRAINT %s FOREIGN KEY (", (char *)tablebuf);
@@ -1455,20 +1457,22 @@ dict_foreign_def_get(
 
 	strcat(fk_def,(char *)") REFERENCES ");
 
-	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
-	        foreign->referenced_table_name,
-		strlen(foreign->referenced_table_name),
-		trx->mysql_thd, TRUE);
+	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	        	        foreign->referenced_table_name,
+			        strlen(foreign->referenced_table_name),
+			        trx->mysql_thd, TRUE);
+	tablebuf[bufend - tablebuf] = '\0';
 
 	strcat(fk_def, tablebuf);
 	strcat(fk_def, " (");
 
 	for(i = 0; i < foreign->n_fields; i++) {
 		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+		bufend = innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->referenced_col_names[i],
 				strlen(foreign->referenced_col_names[i]),
 				trx->mysql_thd, FALSE);
+		buf[bufend - buf] = '\0';
 		strcat(fk_def, buf);
 		if (i < foreign->n_fields-1) {
 			strcat(fk_def, (char *)",");
@@ -1492,18 +1496,25 @@ dict_foreign_def_get_fields(
 	char**		field2, /*!< out: referenced column */
 	int		col_no) /*!< in: column number */
 {
-	*field = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-	*field2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-
-	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
-		foreign->foreign_col_names[col_no],
-		strlen(foreign->foreign_col_names[col_no]),
-		trx->mysql_thd, FALSE);
-
-	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
-		foreign->referenced_col_names[col_no],
-		strlen(foreign->referenced_col_names[col_no]),
-		trx->mysql_thd, FALSE);
+	char* bufend;
+	char* fieldbuf = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+	char* fieldbuf2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+
+	bufend = innobase_convert_name(fieldbuf, MAX_TABLE_NAME_LEN,
+			foreign->foreign_col_names[col_no],
+			strlen(foreign->foreign_col_names[col_no]),
+			trx->mysql_thd, FALSE);
+
+	fieldbuf[bufend - fieldbuf] = '\0';
+
+	bufend = innobase_convert_name(fieldbuf2, MAX_TABLE_NAME_LEN,
+			foreign->referenced_col_names[col_no],
+			strlen(foreign->referenced_col_names[col_no]),
+			trx->mysql_thd, FALSE);
+
+	fieldbuf2[bufend - fieldbuf2] = '\0';
+	*field = fieldbuf;
+	*field2 = fieldbuf2;
 }
 
 /********************************************************************//**
diff --git a/storage/innobase/dict/dict0dict.c b/storage/innobase/dict/dict0dict.c
index 4211d864d7c..c803169dbd7 100644
--- a/storage/innobase/dict/dict0dict.c
+++ b/storage/innobase/dict/dict0dict.c
@@ -3746,7 +3746,7 @@ dict_create_foreign_constraints_low(
 	const char*	referenced_table_name;
 	const char*	create_table_name;
 	const char*	orig;
-	const char	create_name[MAX_TABLE_NAME_LEN + 1];
+	char		create_name[MAX_TABLE_NAME_LEN + 1];
 	const char	operation[8];
 
 	ut_ad(mutex_own(&(dict_sys->mutex)));
@@ -3770,14 +3770,18 @@ dict_create_foreign_constraints_low(
 		}
 
 		if (success) {
-			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-				create_table_name, strlen(create_table_name),
-				trx->mysql_thd, TRUE);
+			char *bufend;
+			bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+					create_table_name, strlen(create_table_name),
+					trx->mysql_thd, TRUE);
+			create_name[bufend-create_name]='\0';
 			ptr = orig;
 		} else {
+			char *bufend;
 			ptr = orig;
-			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-				name, strlen(name), trx->mysql_thd, TRUE);
+			bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+					name, strlen(name), trx->mysql_thd, TRUE);
+			create_name[bufend-create_name]='\0';
 		}
 
 		goto loop;
@@ -3819,13 +3823,18 @@ dict_create_foreign_constraints_low(
 				   &success, heap, &referenced_table_name);
 
 	if (table_to_alter) {
-		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-			table_to_alter->name, strlen(table_to_alter->name),
-			trx->mysql_thd, TRUE);
+		char *bufend;
+		bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				table_to_alter->name, strlen(table_to_alter->name),
+				trx->mysql_thd, TRUE);
+		create_name[bufend-create_name]='\0';
 	} else {
-		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-			referenced_table_name, strlen(referenced_table_name),
-			trx->mysql_thd, TRUE);
+		char *bufend;
+		bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				referenced_table_name, strlen(referenced_table_name),
+				trx->mysql_thd, TRUE);
+		create_name[bufend-create_name]='\0';
+
 	}
 
 	if (!success) {
@@ -4128,10 +4137,12 @@ col_loop1:
 
 	if (!success || (!referenced_table && trx->check_foreigns)) {
 		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		char*	bufend;
 
-		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-			referenced_table_name, strlen(referenced_table_name),
-			trx->mysql_thd, TRUE);
+		bufend = innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				referenced_table_name, strlen(referenced_table_name),
+				trx->mysql_thd, TRUE);
+		buf[bufend - buf] = '\0';
 
 		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
 			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
diff --git a/storage/xtradb/dict/dict0crea.c b/storage/xtradb/dict/dict0crea.c
index 64a6d706557..f7663b999b7 100644
--- a/storage/xtradb/dict/dict0crea.c
+++ b/storage/xtradb/dict/dict0crea.c
@@ -1640,10 +1640,12 @@ dict_foreign_def_get(
 	const char* tbname;
 	char tablebuf[MAX_TABLE_NAME_LEN + 1] = "";
 	int i;
+	char* bufend;
 
 	tbname = dict_remove_db_name(foreign->id);
-	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
 				tbname, strlen(tbname), trx->mysql_thd, FALSE);
+	tablebuf[bufend - tablebuf] = '\0';
 
 	sprintf(fk_def,
 		(char *)"CONSTRAINT %s FOREIGN KEY (", (char *)tablebuf);
@@ -1662,20 +1664,22 @@ dict_foreign_def_get(
 
 	strcat(fk_def,(char *)") REFERENCES ");
 
-	innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
-	        foreign->referenced_table_name,
-		strlen(foreign->referenced_table_name),
-		trx->mysql_thd, TRUE);
+	bufend = innobase_convert_name(tablebuf, MAX_TABLE_NAME_LEN,
+	        	        foreign->referenced_table_name,
+			        strlen(foreign->referenced_table_name),
+			        trx->mysql_thd, TRUE);
+	tablebuf[bufend - tablebuf] = '\0';
 
 	strcat(fk_def, tablebuf);
 	strcat(fk_def, " (");
 
 	for(i = 0; i < foreign->n_fields; i++) {
 		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
-		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+		bufend = innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
 				foreign->referenced_col_names[i],
 				strlen(foreign->referenced_col_names[i]),
 				trx->mysql_thd, FALSE);
+		buf[bufend - buf] = '\0';
 		strcat(fk_def, buf);
 		if (i < foreign->n_fields-1) {
 			strcat(fk_def, (char *)",");
@@ -1699,18 +1703,25 @@ dict_foreign_def_get_fields(
 	char**		field2, /*!< out: referenced column */
 	int		col_no) /*!< in: column number */
 {
-	*field = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-	*field2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
-
-	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
-		foreign->foreign_col_names[col_no],
-		strlen(foreign->foreign_col_names[col_no]),
-		trx->mysql_thd, FALSE);
-
-	innobase_convert_name(*field, MAX_TABLE_NAME_LEN,
-		foreign->referenced_col_names[col_no],
-		strlen(foreign->referenced_col_names[col_no]),
-		trx->mysql_thd, FALSE);
+	char* bufend;
+	char* fieldbuf = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+	char* fieldbuf2 = mem_heap_alloc(foreign->heap, MAX_TABLE_NAME_LEN+1);
+
+	bufend = innobase_convert_name(fieldbuf, MAX_TABLE_NAME_LEN,
+			foreign->foreign_col_names[col_no],
+			strlen(foreign->foreign_col_names[col_no]),
+			trx->mysql_thd, FALSE);
+
+	fieldbuf[bufend - fieldbuf] = '\0';
+
+	bufend = innobase_convert_name(fieldbuf2, MAX_TABLE_NAME_LEN,
+			foreign->referenced_col_names[col_no],
+			strlen(foreign->referenced_col_names[col_no]),
+			trx->mysql_thd, FALSE);
+
+	fieldbuf2[bufend - fieldbuf2] = '\0';
+	*field = fieldbuf;
+	*field2 = fieldbuf2;
 }
 
 /********************************************************************//**
diff --git a/storage/xtradb/dict/dict0dict.c b/storage/xtradb/dict/dict0dict.c
index 754ddfa752d..d18184f6e30 100644
--- a/storage/xtradb/dict/dict0dict.c
+++ b/storage/xtradb/dict/dict0dict.c
@@ -3879,7 +3879,7 @@ dict_create_foreign_constraints_low(
 	const char*	referenced_table_name;
 	const char*	create_table_name;
 	const char*	orig;
-	const char	create_name[MAX_TABLE_NAME_LEN + 1];
+	char		create_name[MAX_TABLE_NAME_LEN + 1];
 	const char	operation[8];
 
 	ut_ad(mutex_own(&(dict_sys->mutex)));
@@ -3903,14 +3903,18 @@ dict_create_foreign_constraints_low(
 		}
 
 		if (success) {
-			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-				create_table_name, strlen(create_table_name),
-				trx->mysql_thd, TRUE);
+			char *bufend;
+			bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+					create_table_name, strlen(create_table_name),
+					trx->mysql_thd, TRUE);
+			create_name[bufend-create_name]='\0';
 			ptr = orig;
 		} else {
+			char *bufend;
 			ptr = orig;
-			innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-				name, strlen(name), trx->mysql_thd, TRUE);
+			bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+					name, strlen(name), trx->mysql_thd, TRUE);
+			create_name[bufend-create_name]='\0';
 		}
 
 		goto loop;
@@ -3952,13 +3956,18 @@ dict_create_foreign_constraints_low(
 				   &success, heap, &referenced_table_name);
 
 	if (table_to_alter) {
-		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-			table_to_alter->name, strlen(table_to_alter->name),
-			trx->mysql_thd, TRUE);
+		char *bufend;
+		bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				table_to_alter->name, strlen(table_to_alter->name),
+				trx->mysql_thd, TRUE);
+		create_name[bufend-create_name]='\0';
 	} else {
-		innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
-			referenced_table_name, strlen(referenced_table_name),
-			trx->mysql_thd, TRUE);
+		char *bufend;
+		bufend = innobase_convert_name((char *)create_name, MAX_TABLE_NAME_LEN,
+				referenced_table_name, strlen(referenced_table_name),
+				trx->mysql_thd, TRUE);
+		create_name[bufend-create_name]='\0';
+
 	}
 
 	if (!success) {
@@ -4261,10 +4270,12 @@ col_loop1:
 
 	if (!success || (!referenced_table && trx->check_foreigns)) {
 		char	buf[MAX_TABLE_NAME_LEN + 1] = "";
+		char*	bufend;
 
-		innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
-			referenced_table_name, strlen(referenced_table_name),
-			trx->mysql_thd, TRUE);
+		bufend = innobase_convert_name(buf, MAX_TABLE_NAME_LEN,
+				referenced_table_name, strlen(referenced_table_name),
+				trx->mysql_thd, TRUE);
+		buf[bufend - buf] = '\0';
 
 		ib_push_warning(trx, DB_CANNOT_ADD_CONSTRAINT,
 			"%s table %s with foreign key constraint failed. Referenced table %s not found in the data dictionary "
-- 
cgit v1.2.1


From bfe2689cf642aac122c8cf8493863dff38f69558 Mon Sep 17 00:00:00 2001
From: Sergey Vojtovich <svoj@mariadb.org>
Date: Fri, 31 Jul 2015 13:13:39 +0400
Subject: MDEV-8379 - SUSE mariadb patches

Let mysql_upgrade return zero exit status when installation is up to date.
---
 client/mysql_upgrade.c          | 3 ++-
 mysql-test/t/mysql_upgrade.test | 1 -
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/client/mysql_upgrade.c b/client/mysql_upgrade.c
index d513d5d852d..ee6845def68 100644
--- a/client/mysql_upgrade.c
+++ b/client/mysql_upgrade.c
@@ -1061,7 +1061,7 @@ int main(int argc, char **argv)
     printf("This installation of MySQL is already upgraded to %s, "
            "use --force if you still need to run mysql_upgrade\n",
            MYSQL_SERVER_VERSION);
-    die(NULL);
+    goto end;
   }
 
   if (opt_version_check && check_version_match())
@@ -1084,6 +1084,7 @@ int main(int argc, char **argv)
   /* Create a file indicating upgrade has been performed */
   create_mysql_upgrade_info_file();
 
+end:
   free_used_memory();
   my_end(my_end_arg);
   exit(0);
diff --git a/mysql-test/t/mysql_upgrade.test b/mysql-test/t/mysql_upgrade.test
index e4923e5f429..13be03aa9bb 100644
--- a/mysql-test/t/mysql_upgrade.test
+++ b/mysql-test/t/mysql_upgrade.test
@@ -14,7 +14,6 @@ file_exists $MYSQLD_DATADIR/mysql_upgrade_info;
 
 --echo Run it again - should say already completed
 --replace_result $MYSQL_SERVER_VERSION VERSION
---error 1
 --exec $MYSQL_UPGRADE 2>&1
 
 # It should have created a file in the MySQL Servers datadir
-- 
cgit v1.2.1


From 2721d69f792353e509056819565202483003ab3d Mon Sep 17 00:00:00 2001
From: Sergei Golubchik <serg@mariadb.org>
Date: Tue, 28 Jul 2015 19:11:53 +0200
Subject: MDEV-8352 Increase Diffie-Helman modulus to 2048-bits

---
 vio/viosslfactories.c | 47 +++++++++++++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/vio/viosslfactories.c b/vio/viosslfactories.c
index 78916f843e0..c889b90a2e2 100644
--- a/vio/viosslfactories.c
+++ b/vio/viosslfactories.c
@@ -21,31 +21,42 @@
 static my_bool     ssl_algorithms_added    = FALSE;
 static my_bool     ssl_error_strings_loaded= FALSE;
 
-/* the function below was generated with "openssl dhparam -2 -C 1024" */
+/* the function below was generated with "openssl dhparam -2 -C 2048" */
 static
-DH *get_dh1024()
+DH *get_dh2048()
 {
-  static unsigned char dh1024_p[]={
-    0xEC,0x46,0x7E,0xF9,0x4E,0x10,0x29,0xDC,0x44,0x97,0x71,0xFD,
-    0x71,0xC6,0x9F,0x0D,0xD1,0x09,0xF6,0x58,0x6F,0xAD,0xCA,0xF4,
-    0x37,0xD5,0xC3,0xBD,0xC3,0x9A,0x51,0x66,0x2C,0x58,0xBD,0x02,
-    0xBD,0xBA,0xBA,0xFC,0xE7,0x0E,0x5A,0xE5,0x97,0x81,0xC3,0xF3,
-    0x28,0x2D,0xAD,0x00,0x91,0xEF,0xF8,0xF0,0x5D,0xE9,0xE7,0x18,
-    0xE2,0xAD,0xC4,0x70,0xC5,0x3C,0x12,0x8A,0x80,0x6A,0x9F,0x3B,
-    0x00,0xA2,0x8F,0xA9,0x26,0xB0,0x0E,0x7F,0xED,0xF6,0xC2,0x03,
-    0x81,0xB5,0xC5,0x41,0xD0,0x00,0x2B,0x21,0xD4,0x4B,0x74,0xA6,
-    0xD7,0x1A,0x0E,0x82,0xC8,0xEE,0xD4,0xB1,0x6F,0xB4,0x79,0x01,
-    0x8A,0xF1,0x12,0xD7,0x3C,0xFD,0xCB,0x9B,0xAE,0x1C,0xA9,0x0F,
-    0x3D,0x0F,0xF8,0xD6,0x7D,0xDE,0xD6,0x0B,
+  static unsigned char dh2048_p[]={
+    0xA1,0xBB,0x7C,0x20,0xC5,0x5B,0xC0,0x7B,0x21,0x8B,0xD6,0xA8,
+    0x15,0xFC,0x3B,0xBA,0xAB,0x9F,0xDF,0x68,0xC4,0x79,0x78,0x0D,
+    0xC1,0x12,0x64,0xE4,0x15,0xC9,0x66,0xDB,0xF6,0xCB,0xB3,0x39,
+    0x02,0x5B,0x78,0x62,0xFB,0x09,0xAE,0x09,0x6B,0xDD,0xD4,0x5D,
+    0x97,0xBC,0xDC,0x7F,0xE6,0xD6,0xF1,0xCB,0xF5,0xEB,0xDA,0xA7,
+    0x2E,0x5A,0x43,0x2B,0xE9,0x40,0xE2,0x85,0x00,0x1C,0xC0,0x0A,
+    0x98,0x77,0xA9,0x31,0xDE,0x0B,0x75,0x4D,0x1E,0x1F,0x16,0x83,
+    0xCA,0xDE,0xBD,0x21,0xFC,0xC1,0x82,0x37,0x36,0x33,0x0B,0x66,
+    0x06,0x3C,0xF3,0xAF,0x21,0x57,0x57,0x80,0xF6,0x94,0x1B,0xA9,
+    0xD4,0xF6,0x8F,0x18,0x62,0x0E,0xC4,0x22,0xF9,0x5B,0x62,0xCC,
+    0x3F,0x19,0x95,0xCF,0x4B,0x00,0xA6,0x6C,0x0B,0xAF,0x9F,0xD5,
+    0xFA,0x3D,0x6D,0xDA,0x30,0x83,0x07,0x91,0xAC,0x15,0xFF,0x8F,
+    0x59,0x54,0xEA,0x25,0xBC,0x4E,0xEB,0x6A,0x54,0xDF,0x75,0x09,
+    0x72,0x0F,0xEF,0x23,0x70,0xE0,0xA8,0x04,0xEA,0xFF,0x90,0x54,
+    0xCD,0x84,0x18,0xC0,0x75,0x91,0x99,0x0F,0xA1,0x78,0x0C,0x07,
+    0xB7,0xC5,0xDE,0x55,0x06,0x7B,0x95,0x68,0x2C,0x33,0x39,0xBC,
+    0x2C,0xD0,0x6D,0xDD,0xFA,0xDC,0xB5,0x8F,0x82,0x39,0xF8,0x67,
+    0x44,0xF1,0xD8,0xF7,0x78,0x11,0x9A,0x77,0x9B,0x53,0x47,0xD6,
+    0x2B,0x5D,0x67,0xB8,0xB7,0xBC,0xC1,0xD7,0x79,0x62,0x15,0xC2,
+    0xC5,0x83,0x97,0xA7,0xF8,0xB4,0x9C,0xF6,0x8F,0x9A,0xC7,0xDA,
+    0x1B,0xBB,0x87,0x07,0xA7,0x71,0xAD,0xB2,0x8A,0x50,0xF8,0x26,
+    0x12,0xB7,0x3E,0x0B,
   };
-  static unsigned char dh1024_g[]={
+  static unsigned char dh2048_g[]={
     0x02,
   };
   DH *dh;
 
   if ((dh=DH_new()) == NULL) return(NULL);
-  dh->p=BN_bin2bn(dh1024_p,sizeof(dh1024_p),NULL);
-  dh->g=BN_bin2bn(dh1024_g,sizeof(dh1024_g),NULL);
+  dh->p=BN_bin2bn(dh2048_p,sizeof(dh2048_p),NULL);
+  dh->g=BN_bin2bn(dh2048_g,sizeof(dh2048_g),NULL);
   if ((dh->p == NULL) || (dh->g == NULL))
   { DH_free(dh); return(NULL); }
   return(dh);
@@ -259,7 +270,7 @@ new_VioSSLFd(const char *key_file, const char *cert_file,
   }
 
   /* DH stuff */
-  dh=get_dh1024();
+  dh=get_dh2048();
   SSL_CTX_set_tmp_dh(ssl_fd->ssl_context, dh);
   DH_free(dh);
 
-- 
cgit v1.2.1


From 4d5772c578bd336b1004084ad7925143137c8a4e Mon Sep 17 00:00:00 2001
From: Sergei Golubchik <serg@mariadb.org>
Date: Fri, 31 Jul 2015 10:13:01 +0200
Subject: MDEV-7810 Wrong result on execution of a query as a PS (both 1st and
 further executions)

Alternative fix that doesn't cause view.test crash in --ps:
Remember when Item_ref was fixed right in the constructor
and did not have a full Item_ref::fix_fields() call. Later
in PS/SP, after Item_ref::cleanup, we use this knowledge
to avoid doing full fix_fields() for items that were never
supposed to be fix_field'ed.

Simplify the test case.
---
 mysql-test/r/subselect_mat.result    | 13 ++-----------
 mysql-test/r/subselect_sj_mat.result | 13 ++-----------
 mysql-test/t/subselect_sj_mat.test   |  8 ++------
 sql/item.cc                          | 10 +++++++---
 sql/item.h                           |  5 +++--
 sql/item_subselect.cc                | 31 -------------------------------
 sql/sql_base.cc                      |  2 ++
 7 files changed, 18 insertions(+), 64 deletions(-)

diff --git a/mysql-test/r/subselect_mat.result b/mysql-test/r/subselect_mat.result
index 8c25577eb01..e4843929fcb 100644
--- a/mysql-test/r/subselect_mat.result
+++ b/mysql-test/r/subselect_mat.result
@@ -2150,20 +2150,11 @@ drop database mysqltest4;
 # (both 1st and further executions)
 CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
 INSERT INTO t1 VALUES (0),(8);
-SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
-a
-0
-8
-SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
-MIN(t3.a)
-0
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2));
 a
 0
 PREPARE stmt FROM "
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2))
 ";
 execute stmt;
 a
diff --git a/mysql-test/r/subselect_sj_mat.result b/mysql-test/r/subselect_sj_mat.result
index 6c69d195bd3..cfcbf612030 100644
--- a/mysql-test/r/subselect_sj_mat.result
+++ b/mysql-test/r/subselect_sj_mat.result
@@ -2190,20 +2190,11 @@ drop database mysqltest4;
 # (both 1st and further executions)
 CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
 INSERT INTO t1 VALUES (0),(8);
-SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
-a
-0
-8
-SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
-MIN(t3.a)
-0
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2));
 a
 0
 PREPARE stmt FROM "
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2))
 ";
 execute stmt;
 a
diff --git a/mysql-test/t/subselect_sj_mat.test b/mysql-test/t/subselect_sj_mat.test
index 63c72f20e21..dd30b21201d 100644
--- a/mysql-test/t/subselect_sj_mat.test
+++ b/mysql-test/t/subselect_sj_mat.test
@@ -1848,13 +1848,9 @@ drop database mysqltest4;
 CREATE TABLE t1 (a INT NOT NULL) ENGINE=MyISAM;
 INSERT INTO t1 VALUES (0),(8);
 
-SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2;
-SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a));
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) );
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2));
 PREPARE stmt FROM "
-SELECT a FROM ( SELECT DISTINCT t9.* FROM t1 AS t9, t1 AS t2 ) AS sq 
-WHERE a IN ( SELECT MIN(t3.a) FROM ( t1 AS t3 INNER JOIN t1 AS t4 ON (t3.a = t4.a) ) )
+SELECT a FROM (SELECT DISTINCT * FROM t1) AS sq WHERE a IN (SELECT MIN(t2.a) FROM (t1 AS t2))
 ";
 execute stmt;
 execute stmt;
diff --git a/sql/item.cc b/sql/item.cc
index 9b3e9a546c6..878c9604ca2 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -6754,7 +6754,7 @@ Item_ref::Item_ref(Name_resolution_context *context_arg,
   /*
     This constructor used to create some internals references over fixed items
   */
-  if (ref && *ref && (*ref)->fixed)
+  if ((set_properties_only= (ref && *ref && (*ref)->fixed)))
     set_properties();
 }
 
@@ -6798,7 +6798,7 @@ Item_ref::Item_ref(TABLE_LIST *view_arg, Item **item,
   /*
     This constructor is used to create some internal references over fixed items
   */
-  if (ref && *ref && (*ref)->fixed)
+  if ((set_properties_only= (ref && *ref && (*ref)->fixed)))
     set_properties();
 }
 
@@ -6873,7 +6873,11 @@ bool Item_ref::fix_fields(THD *thd, Item **reference)
   DBUG_ASSERT(fixed == 0);
   SELECT_LEX *current_sel= thd->lex->current_select;
 
-  if (!ref || ref == not_found_item)
+  if (set_properties_only)
+  {
+    /* do nothing */
+  }
+  else if (!ref || ref == not_found_item)
   {
     DBUG_ASSERT(reference_trough_name != 0);
     if (!(ref= resolve_ref_in_select_and_group(thd, this,
diff --git a/sql/item.h b/sql/item.h
index a38a25dfc75..f8e8ead47dd 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -2946,6 +2946,7 @@ class Item_ref :public Item_ident
 {
 protected:
   void set_properties();
+  bool set_properties_only; // the item doesn't need full fix_fields
 public:
   enum Ref_Type { REF, DIRECT_REF, VIEW_REF, OUTER_REF, AGGREGATE_REF };
   Field *result_field;			 /* Save result here */
@@ -2955,7 +2956,7 @@ public:
            const char *db_arg, const char *table_name_arg,
            const char *field_name_arg)
     :Item_ident(context_arg, db_arg, table_name_arg, field_name_arg),
-    result_field(0), ref(0), reference_trough_name(1) {}
+    set_properties_only(0), result_field(0), ref(0), reference_trough_name(1) {}
   /*
     This constructor is used in two scenarios:
     A) *item = NULL
@@ -2978,7 +2979,7 @@ public:
 
   /* Constructor need to process subselect with temporary tables (see Item) */
   Item_ref(THD *thd, Item_ref *item)
-    :Item_ident(thd, item), result_field(item->result_field), ref(item->ref) {}
+    :Item_ident(thd, item), set_properties_only(0), result_field(item->result_field), ref(item->ref) {}
   enum Type type() const		{ return REF_ITEM; }
   enum Type real_type() const           { return ref ? (*ref)->type() :
                                           REF_ITEM; }
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 3b280c45608..4837cb45a91 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -2007,37 +2007,6 @@ Item_in_subselect::create_single_in_to_exists_cond(JOIN *join,
   *where_item= NULL;
   *having_item= NULL;
 
-  /*
-    For PS we have to do fix_fields(expr) here to ensure that it's
-    evaluated in the outer context.  If not, then fix_having() will do
-    a fix_fields(expr) in the inner context and mark expr as
-    'depended', which will cause update_ref_and_keys() to find wrong
-    keys.
-    When not running PS, fix_fields(expr) as already been done earlier and
-    the following test does nothing.
-  */
-  if (expr && !expr->fixed)
-  {
-    bool tmp;
-    SELECT_LEX *save_current_select= thd->lex->current_select;
-    Item_subselect *save_item;
-
-    thd->lex->current_select= thd->lex->current_select->outer_select();
-    /*
-      For st_select_lex::mark_as_dependent, who needs to mark
-      this sub query as correlated.
-    */
-    save_item= thd->lex->current_select->master_unit()->item;
-    thd->lex->current_select->master_unit()->item= this;
-
-    tmp= expr->fix_fields(thd, 0);
-
-    thd->lex->current_select->master_unit()->item= save_item;
-    thd->lex->current_select= save_current_select;
-    if (tmp)
-      DBUG_RETURN(true);
-  }
-
   if (join_having || select_lex->with_sum_func ||
       select_lex->group_list.elements)
   {
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index aefa82405ff..384ab7a7322 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -6936,6 +6936,8 @@ find_field_in_tables(THD *thd, Item_ident *item,
       return found;
     }
   }
+  else
+    item->can_be_depended= TRUE;
 
   if (db && lower_case_table_names)
   {
-- 
cgit v1.2.1


From 79deefc4d798f912580ab10786a46d262bc21f28 Mon Sep 17 00:00:00 2001
From: Sergei Golubchik <serg@mariadb.org>
Date: Fri, 31 Jul 2015 12:31:37 +0200
Subject: MDEV-8340 Add "mysqlbinlog --binlog-row-event-max-size" support for
 MariaDB 5.5

Cherry-pick from 10.0:

  commit 126523d1906727254ad0f887db688b60b23ebed6
  Author: Sergei Golubchik <serg@mariadb.org>
  Date:   Mon Feb 23 20:53:41 2015 +0100

  MDEV-6703 Add "mysqlbinlog --binlog-row-event-max-size" support
---
 client/mysqlbinlog.cc |  7 +++++++
 sql/log_event.cc      | 12 +++++++-----
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/client/mysqlbinlog.cc b/client/mysqlbinlog.cc
index 57492577e91..250dc609891 100644
--- a/client/mysqlbinlog.cc
+++ b/client/mysqlbinlog.cc
@@ -66,6 +66,7 @@ ulong server_id = 0;
 ulong bytes_sent = 0L, bytes_received = 0L;
 ulong mysqld_net_retry_count = 10L;
 ulong open_files_limit;
+ulong opt_binlog_rows_event_max_size;
 uint test_flags = 0; 
 static uint opt_protocol= 0;
 static FILE *result_file;
@@ -1432,6 +1433,12 @@ that may lead to an endless loop.",
    "Used to reserve file descriptors for use by this program.",
    &open_files_limit, &open_files_limit, 0, GET_ULONG,
    REQUIRED_ARG, MY_NFILE, 8, OS_FILE_LIMIT, 0, 1, 0},
+  {"binlog-row-event-max-size", 0,
+   "The maximum size of a row-based binary log event in bytes. Rows will be "
+   "grouped into events smaller than this size if possible. "
+   "This value must be a multiple of 256.",
+   &opt_binlog_rows_event_max_size, &opt_binlog_rows_event_max_size, 0,
+   GET_ULONG, REQUIRED_ARG, UINT_MAX,  256, ULONG_MAX,  0, 256,  0},
   {"verify-binlog-checksum", 'c', "Verify checksum binlog events.",
    (uchar**) &opt_verify_binlog_checksum, (uchar**) &opt_verify_binlog_checksum,
    0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
diff --git a/sql/log_event.cc b/sql/log_event.cc
index e63884eaeab..2d5c3f232a4 100644
--- a/sql/log_event.cc
+++ b/sql/log_event.cc
@@ -1249,9 +1249,10 @@ int Log_event::read_log_event(IO_CACHE* file, String* packet,
   }
   data_len= uint4korr(buf + EVENT_LEN_OFFSET);
   if (data_len < LOG_EVENT_MINIMAL_HEADER_LEN ||
-      data_len > current_thd->variables.max_allowed_packet)
+      data_len > max(current_thd->variables.max_allowed_packet,
+                     opt_binlog_rows_event_max_size + MAX_LOG_EVENT_HEADER))
   {
-    DBUG_PRINT("error",("data_len: %ld", data_len));
+    DBUG_PRINT("error",("data_len: %lu", data_len));
     result= ((data_len < LOG_EVENT_MINIMAL_HEADER_LEN) ? LOG_READ_BOGUS :
 	     LOG_READ_TOO_LARGE);
     goto end;
@@ -1372,7 +1373,7 @@ failed my_b_read"));
     */
     DBUG_RETURN(0);
   }
-  uint data_len = uint4korr(head + EVENT_LEN_OFFSET);
+  ulong data_len = uint4korr(head + EVENT_LEN_OFFSET);
   char *buf= 0;
   const char *error= 0;
   Log_event *res=  0;
@@ -1381,7 +1382,8 @@ failed my_b_read"));
   uint max_allowed_packet= thd ? slave_max_allowed_packet:~(uint)0;
 #endif
 
-  if (data_len > max_allowed_packet)
+  if (data_len > max(max_allowed_packet,
+                     opt_binlog_rows_event_max_size + MAX_LOG_EVENT_HEADER))
   {
     error = "Event too big";
     goto err;
@@ -1415,7 +1417,7 @@ err:
   {
     DBUG_ASSERT(error != 0);
     sql_print_error("Error in Log_event::read_log_event(): "
-                    "'%s', data_len: %d, event_type: %d",
+                    "'%s', data_len: %lu, event_type: %d",
 		    error,data_len,head[EVENT_TYPE_OFFSET]);
     my_free(buf);
     /*
-- 
cgit v1.2.1


From 409709ec7edc0dd6eb725e766f0d4c52192accfc Mon Sep 17 00:00:00 2001
From: Sergei Golubchik <serg@mariadb.org>
Date: Fri, 31 Jul 2015 20:33:10 +0200
Subject: compilation error on windows

---
 sql/sql_class.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/sql/sql_class.h b/sql/sql_class.h
index 8d51120e428..68563ab12b2 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -58,7 +58,7 @@ class Rows_log_event;
 class Sroutine_hash_entry;
 class User_level_lock;
 class user_var_entry;
-class Trans_binlog_info;
+struct Trans_binlog_info;
 
 enum enum_enable_or_disable { LEAVE_AS_IS, ENABLE, DISABLE };
 enum enum_ha_read_modes { RFIRST, RNEXT, RPREV, RLAST, RKEY, RNEXT_SAME };
-- 
cgit v1.2.1


From 96badb16afcf8a6ae3d03918419fc51ace4be236 Mon Sep 17 00:00:00 2001
From: Sergei Golubchik <serg@mariadb.org>
Date: Fri, 31 Jul 2015 22:09:46 +0200
Subject: MDEV-7821 Server crashes in Item_func_group_concat::fix_fields on 2nd
 execution of PS

Correct fix for this bug.

The problem was that Item_func_group_concat() was calling
setup_order(), passing args as the second argument,
ref_pointer_array. While ref_pointer_array should have free
space at the end, as setup_order() can append elements to it.

In this particular case args[] elements were overwritten when
setup_order() was pushing new elements into ref_pointer_array.
---
 sql/item_sum.cc | 16 ++++++++++------
 sql/item_sum.h  |  1 +
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/sql/item_sum.cc b/sql/item_sum.cc
index a24307b131b..9000289fd33 100644
--- a/sql/item_sum.cc
+++ b/sql/item_sum.cc
@@ -3300,8 +3300,6 @@ void Item_func_group_concat::cleanup()
     from Item_func_group_concat::setup() to point to runtime
     created objects, we need to reset them back to the original
     arguments of the function.
-
-    The very same applies to args array.
   */
   ORDER **order_ptr= order;
   for (uint i= 0; i < arg_count_order; i++)
@@ -3309,7 +3307,6 @@ void Item_func_group_concat::cleanup()
     (*order_ptr)->item= &args[arg_count_field + i];
     order_ptr++;
   }
-  memcpy(args, orig_args, sizeof(Item *) * arg_count);
   DBUG_VOID_RETURN;
 }
 
@@ -3517,9 +3514,16 @@ bool Item_func_group_concat::setup(THD *thd)
     "all_fields". The resulting field list is used as input to create
     tmp table columns.
   */
-  if (arg_count_order &&
-      setup_order(thd, args, context->table_list, list, all_fields, *order))
-    DBUG_RETURN(TRUE);
+  if (arg_count_order)
+  {
+    uint n_elems= arg_count_order + all_fields.elements;
+    ref_pointer_array= static_cast<Item**>(thd->alloc(sizeof(Item*) * n_elems));
+    memcpy(ref_pointer_array, args, arg_count * sizeof(Item*));
+    if (!ref_pointer_array ||
+        setup_order(thd, ref_pointer_array, context->table_list, list,
+                    all_fields, *order))
+      DBUG_RETURN(TRUE);
+  }
 
   count_field_types(select_lex, tmp_table_param, all_fields, 0);
   tmp_table_param->force_copy_fields= force_copy_fields;
diff --git a/sql/item_sum.h b/sql/item_sum.h
index f074cc6c822..86093f5d4f5 100644
--- a/sql/item_sum.h
+++ b/sql/item_sum.h
@@ -1394,6 +1394,7 @@ class Item_func_group_concat : public Item_sum
   String *separator;
   TREE tree_base;
   TREE *tree;
+  Item **ref_pointer_array;
 
   /**
      If DISTINCT is used with this GROUP_CONCAT, this member is used to filter
-- 
cgit v1.2.1