From: Anitha Gopi
Date: May 27 2011 4:54am
Subject: bzr commit into mysql-trunk branch (anitha.gopi:3118)
List-Archive: http://lists.mysql.com/commits/138274
Message-Id: <201105270455.p4R4tewh007930@acsmt357.oracle.com>
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="===============1763045711=="

--===============1763045711==
MIME-Version: 1.0
Content-Type: text/plain; charset="us-ascii"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

#At file:///home/anitha/mysql/repo/mysql-trunk-mod/ based on revid:anitha.gopi@stripped

 3118 Anitha Gopi	2011-05-27 [merge]
      Automerge : Update local tree

    added:
      mysql-test/suite/binlog/r/binlog_reset_master.result
      mysql-test/suite/binlog/t/binlog_reset_master.test
      mysql-test/suite/rpl/t/rpl_typeconv-master.opt
    modified:
      BUILD/SETUP.sh
      cmake/configure.pl
      cmake/os/WindowsCache.cmake
      include/violite.h
      libmysql/errmsg.c
      mysql-test/include/subquery.inc
      mysql-test/lib/mtr_misc.pl
      mysql-test/mysql-test-run.pl
      mysql-test/r/func_math.result
      mysql-test/r/openssl_1.result
      mysql-test/r/subquery_nomat_nosj.result
      mysql-test/r/subquery_none.result
      mysql-test/suite/innodb/r/innodb_mysql.result
      mysql-test/suite/innodb/t/innodb_mysql.test
      mysql-test/t/func_math.test
      sql-common/client.c
      sql/binlog.cc
      sql/item_func.cc
      sql/item_subselect.cc
      sql/mysqld.cc
      sql/sql_acl.cc
      sql/sql_array.h
      sql/sql_base.cc
      sql/sql_parse.cc
      sql/sql_select.cc
      sql/sql_select.h
      storage/innobase/handler/i_s.cc
      storage/innobase/lock/lock0lock.c
      storage/innobase/que/que0que.c
      storage/innobase/srv/srv0start.c
      vio/test-ssl.c
      vio/test-sslclient.c
      vio/test-sslserver.c
      vio/viossl.c
      vio/viosslfactories.c
      vio/viotest-ssl.c
=== modified file 'BUILD/SETUP.sh'
--- a/BUILD/SETUP.sh	2011-05-06 13:21:38 +0000
+++ b/BUILD/SETUP.sh	2011-05-25 10:45:37 +0000
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-# Copyright (C) 2000, 2007 MySQL AB
+# Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
 #
 # This program is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Library General Public
@@ -250,7 +250,7 @@ gcov_compile_flags="$gcov_compile_flags 
 
 gcov_link_flags="-fprofile-arcs -ftest-coverage"
 
-gcov_configs="--disable-shared"
+gcov_configs="--with-gcov"
 
 # gprof
 

=== modified file 'cmake/configure.pl'
--- a/cmake/configure.pl	2010-11-12 01:40:51 +0000
+++ b/cmake/configure.pl	2011-05-25 10:45:37 +0000
@@ -195,6 +195,11 @@ foreach my $option (@ARGV)
     $cmakeargs = $cmakeargs." \"-DWITH_COMMENT=".substr($option,13)."\""; 
     next;
   }
+  if ($option =~ /with-gcov/)
+  {
+      $cmakeargs = $cmakeargs." -DENABLE_GCOV=ON"; 
+      next;
+  }
 
   $option = uc($option);
   $option =~ s/-/_/g;

=== modified file 'cmake/os/WindowsCache.cmake'
--- a/cmake/os/WindowsCache.cmake	2011-04-30 05:36:44 +0000
+++ b/cmake/os/WindowsCache.cmake	2011-05-26 08:14:09 +0000
@@ -347,6 +347,7 @@ SET(SIGNAL_RETURN_TYPE_IS_VOID 1 CACHE I
 SET(C_HAS_inline CACHE INTERNAL "")
 SET(C_HAS___inline 1 CACHE INTERNAL "")
 SET(FIONREAD_IN_SYS_IOCTL CACHE INTERNAL "")
+SET(FIONREAD_IN_SYS_FILIO CACHE INTERNAL "")
 SET(GWINSZ_IN_SYS_IOCTL CACHE INTERNAL "")
 SET(HAVE_CXXABI_H CACHE INTERNAL "")
 SET(HAVE_NDIR_H CACHE INTERNAL "")

=== modified file 'include/violite.h'
--- a/include/violite.h	2011-04-08 10:23:36 +0000
+++ b/include/violite.h	2011-05-19 09:47:43 +0000
@@ -134,13 +134,13 @@ struct st_VioSSLFd
   SSL_CTX *ssl_context;
 };
 
-int sslaccept(struct st_VioSSLFd*, Vio *, long timeout);
-int sslconnect(struct st_VioSSLFd*, Vio *, long timeout);
+int sslaccept(struct st_VioSSLFd*, Vio *, long timeout, unsigned long *errptr);
+int sslconnect(struct st_VioSSLFd*, Vio *, long timeout, unsigned long *errptr);
 
 struct st_VioSSLFd
 *new_VioSSLConnectorFd(const char *key_file, const char *cert_file,
 		       const char *ca_file,  const char *ca_path,
-		       const char *cipher);
+		       const char *cipher, enum enum_ssl_init_error* error);
 struct st_VioSSLFd
 *new_VioSSLAcceptorFd(const char *key_file, const char *cert_file,
 		      const char *ca_file,const char *ca_path,

=== modified file 'libmysql/errmsg.c'
--- a/libmysql/errmsg.c	2011-03-08 19:14:42 +0000
+++ b/libmysql/errmsg.c	2011-05-26 12:36:57 +0000
@@ -51,7 +51,7 @@ const char *client_errors[]=
   "Error on SHOW SLAVE HOSTS:",
   "Error connecting to slave:",
   "Error connecting to master:",
-  "SSL connection error",
+  "SSL connection error: %-.100s",
   "Malformed packet",
   "This client library is licensed only for use with MySQL servers having '%s' license",
   "Invalid use of null pointer",

=== modified file 'mysql-test/include/subquery.inc'
--- a/mysql-test/include/subquery.inc	2011-05-05 07:41:53 +0000
+++ b/mysql-test/include/subquery.inc	2011-05-26 11:09:57 +0000
@@ -5354,3 +5354,32 @@ CREATE TABLE t(a VARCHAR(245) DEFAULT
 INSERT INTO t VALUES (''),(''),(''),(''),(''),(''),(''),(''),(''),(''),('');
 SELECT * FROM (SELECT default(a) FROM t GROUP BY a) d;
 DROP TABLE t;
+
+--echo #
+--echo # Bug 11765699 - 58690: !TABLE || (!TABLE->READ_SET || 
+--echo #                BITMAP_IS_SET(TABLE->READ_SET, FIELD_INDEX
+--echo #
+
+CREATE TABLE t1(a INT);
+INSERT INTO t1 VALUES (0), (1); 
+
+CREATE TABLE t2(
+  b TEXT, 
+  c INT, 
+  PRIMARY KEY (b(1))
+);
+INSERT INTO t2 VALUES ('a', 2), ('b', 3);
+
+SELECT 1 FROM t1 WHERE a = 
+ (SELECT 1 FROM t2 WHERE b = 
+  (SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+   ORDER BY b
+ );
+
+SELECT 1 FROM t1 WHERE a = 
+ (SELECT 1 FROM t2 WHERE b = 
+  (SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+   GROUP BY b
+ );
+
+DROP TABLE t1, t2;

=== modified file 'mysql-test/lib/mtr_misc.pl'
--- a/mysql-test/lib/mtr_misc.pl	2011-04-07 08:39:10 +0000
+++ b/mysql-test/lib/mtr_misc.pl	2011-05-25 10:45:37 +0000
@@ -31,6 +31,7 @@ sub mtr_script_exists(@);
 sub mtr_file_exists(@);
 sub mtr_exe_exists(@);
 sub mtr_exe_maybe_exists(@);
+sub mtr_compress_file($);
 sub mtr_milli_sleep($);
 sub start_timer($);
 sub has_expired($);
@@ -199,6 +200,40 @@ sub mtr_exe_exists (@) {
   }
 }
 
+#
+# Try to compress file using tools that might be available.
+# If zip/gzip is not available, just silently ignore.
+#
+
+sub mtr_compress_file ($) {
+  my ($filename)= @_;
+
+  mtr_error ("File to compress not found: $filename") unless -f $filename;
+
+  my $did_compress= 0;
+
+  if (IS_WINDOWS)
+  {
+    # Capture stderr
+    my $ziperr= `zip $filename.zip $filename 2>&1`;
+    if ($?) {
+      print "$ziperr\n" if $ziperr !~ /recognized as an internal or external/;
+    } else {
+      unlink($filename);
+      $did_compress=1;
+    }
+  }
+  else
+  {
+    my $gzres= system("gzip $filename");
+    $did_compress= ! $gzres;
+    if ($gzres && $gzres != -1) {
+      mtr_error ("Error: have gzip but it fails to compress core file");
+    }
+  }
+  mtr_print("Compressed file $filename") if $did_compress;
+}
+
 
 sub mtr_milli_sleep ($) {
   die "usage: mtr_milli_sleep(milliseconds)" unless @_ == 1;

=== modified file 'mysql-test/mysql-test-run.pl'
--- a/mysql-test/mysql-test-run.pl	2011-05-12 13:49:50 +0000
+++ b/mysql-test/mysql-test-run.pl	2011-05-25 14:48:51 +0000
@@ -264,7 +264,6 @@ my $opt_shutdown_timeout= $ENV{MTR_SHUTD
 my $opt_start_timeout   = $ENV{MTR_START_TIMEOUT}    || 180; # seconds
 
 sub suite_timeout { return $opt_suite_timeout * 60; };
-sub check_timeout { return $opt_testcase_timeout * 6; };
 
 my $opt_wait_all;
 my $opt_user_args;
@@ -300,6 +299,8 @@ sub testcase_timeout ($) {
   return $opt_testcase_timeout * 60;
 }
 
+sub check_timeout ($) { return testcase_timeout($_[0]) / 10; }
+
 our $opt_warnings= 1;
 
 our $opt_include_ndbcluster= 0;
@@ -658,6 +659,8 @@ sub run_test_server ($$$) {
 			     mtr_report(" - deleting it, already saved",
 					"$opt_max_save_core");
 			     unlink("$core_file");
+			   } else {
+			     mtr_compress_file($core_file) unless @opt_cases;
 			   }
 			   ++$num_saved_cores;
 			 }
@@ -3415,7 +3418,7 @@ sub check_testcase($$)
   # Return immediately if no check proceess was started
   return 0 unless ( keys %started );
 
-  my $timeout= start_timer(check_timeout());
+  my $timeout= start_timer(check_timeout($tinfo));
 
   while (1){
     my $result;
@@ -3487,7 +3490,7 @@ test case was executed:\n";
     }
     elsif ( $proc->{timeout} ) {
       $tinfo->{comment}.= "Timeout for 'check-testcase' expired after "
-	.check_timeout()." seconds";
+	.check_timeout($tinfo)." seconds";
       $result= 4;
     }
     else {
@@ -3577,7 +3580,7 @@ sub run_on_all($$)
   # Return immediately if no check proceess was started
   return 0 unless ( keys %started );
 
-  my $timeout= start_timer(check_timeout());
+  my $timeout= start_timer(check_timeout($tinfo));
 
   while (1){
     my $result;
@@ -3608,7 +3611,7 @@ sub run_on_all($$)
     }
     elsif ($proc->{timeout}) {
       $tinfo->{comment}.= "Timeout for '$run' expired after "
-	.check_timeout()." seconds";
+	.check_timeout($tinfo)." seconds";
     }
     else {
       # Unknown process returned, most likley a crash, abort everything
@@ -4333,7 +4336,7 @@ sub check_warnings ($) {
   # Return immediately if no check proceess was started
   return 0 unless ( keys %started );
 
-  my $timeout= start_timer(check_timeout());
+  my $timeout= start_timer(check_timeout($tinfo));
 
   while (1){
     my $result= 0;
@@ -4385,7 +4388,7 @@ sub check_warnings ($) {
     }
     elsif ( $proc->{timeout} ) {
       $tinfo->{comment}.= "Timeout for 'check warnings' expired after "
-	.check_timeout()." seconds";
+	.check_timeout($tinfo)." seconds";
       $result= 4;
     }
     else {

=== modified file 'mysql-test/r/func_math.result'
--- a/mysql-test/r/func_math.result	2011-04-20 07:56:57 +0000
+++ b/mysql-test/r/func_math.result	2011-05-26 10:13:07 +0000
@@ -543,6 +543,12 @@ ROUND(LEAST(15, -4939092, 0.2704), STDDE
 -4939092.0000
 Warnings:
 Warning	1292	Truncated incorrect DOUBLE value: 'a'
+#
+# Bug#12392636  ASSERTION FAILED: SCALE >= 0 && PRECISION > 0 && SCALE <= PRECISION
+#
+SELECT SUM(DISTINCT (TRUNCATE((.1), NULL)));
+SUM(DISTINCT (TRUNCATE((.1), NULL)))
+NULL
 End of 5.1 tests
 #
 # Bug #8433: Overflow must be an error

=== modified file 'mysql-test/r/openssl_1.result'
--- a/mysql-test/r/openssl_1.result	2010-01-29 14:54:27 +0000
+++ b/mysql-test/r/openssl_1.result	2011-05-19 09:47:43 +0000
@@ -44,13 +44,13 @@ ERROR 42000: DELETE command denied to us
 drop user ssl_user1@localhost, ssl_user2@localhost,
 ssl_user3@localhost, ssl_user4@localhost, ssl_user5@localhost;
 drop table t1;
-mysqltest: Could not open connection 'default': 2026 SSL connection error
-mysqltest: Could not open connection 'default': 2026 SSL connection error
-mysqltest: Could not open connection 'default': 2026 SSL connection error
+mysqltest: Could not open connection 'default': 2026 SSL connection error: ASN: bad other signature confirmation
+mysqltest: Could not open connection 'default': 2026 SSL connection error: ASN: bad other signature confirmation
+mysqltest: Could not open connection 'default': 2026 SSL connection error: ASN: bad other signature confirmation
 SSL error: Unable to get private key from ''
-mysqltest: Could not open connection 'default': 2026 SSL connection error
+mysqltest: Could not open connection 'default': 2026 SSL connection error: Unable to get private key
 SSL error: Unable to get certificate from ''
-mysqltest: Could not open connection 'default': 2026 SSL connection error
+mysqltest: Could not open connection 'default': 2026 SSL connection error: Unable to get certificate
 SHOW STATUS LIKE 'Ssl_cipher';
 Variable_name	Value
 Ssl_cipher	DHE-RSA-AES256-SHA
@@ -83,7 +83,7 @@ Ssl_cipher	AES128-SHA
 SHOW STATUS LIKE 'Ssl_cipher';
 Variable_name	Value
 Ssl_cipher	AES128-SHA
-mysqltest: Could not open connection 'default': 2026 SSL connection error
+mysqltest: Could not open connection 'default': 2026 SSL connection error: SSL_CTX_new failed
 CREATE TABLE t1(a int);
 INSERT INTO t1 VALUES (1), (2);
 
@@ -189,7 +189,7 @@ UNLOCK TABLES;
 /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
 
 SSL error: Unable to get private key from 'MYSQL_TEST_DIR/std_data/client-cert.pem'
-mysqldump: Got error: 2026: SSL connection error when trying to connect
+mysqldump: Got error: 2026: SSL connection error: Unable to get private key when trying to connect
 DROP TABLE t1;
 Variable_name	Value
 Ssl_cipher	DHE-RSA-AES256-SHA

=== modified file 'mysql-test/r/subquery_nomat_nosj.result'
--- a/mysql-test/r/subquery_nomat_nosj.result	2011-05-05 07:41:53 +0000
+++ b/mysql-test/r/subquery_nomat_nosj.result	2011-05-26 11:09:57 +0000
@@ -6507,4 +6507,29 @@ SELECT * FROM (SELECT default(a) FROM t 
 default(a)
 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 DROP TABLE t;
+#
+# Bug 11765699 - 58690: !TABLE || (!TABLE->READ_SET || 
+#                BITMAP_IS_SET(TABLE->READ_SET, FIELD_INDEX
+#
+CREATE TABLE t1(a INT);
+INSERT INTO t1 VALUES (0), (1);
+CREATE TABLE t2(
+b TEXT, 
+c INT, 
+PRIMARY KEY (b(1))
+);
+INSERT INTO t2 VALUES ('a', 2), ('b', 3);
+SELECT 1 FROM t1 WHERE a = 
+(SELECT 1 FROM t2 WHERE b = 
+(SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+ORDER BY b
+);
+1
+SELECT 1 FROM t1 WHERE a = 
+(SELECT 1 FROM t2 WHERE b = 
+(SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+GROUP BY b
+);
+1
+DROP TABLE t1, t2;
 set optimizer_switch=default;

=== modified file 'mysql-test/r/subquery_none.result'
--- a/mysql-test/r/subquery_none.result	2011-05-05 07:41:53 +0000
+++ b/mysql-test/r/subquery_none.result	2011-05-26 11:09:57 +0000
@@ -6506,4 +6506,29 @@ SELECT * FROM (SELECT default(a) FROM t 
 default(a)
 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 DROP TABLE t;
+#
+# Bug 11765699 - 58690: !TABLE || (!TABLE->READ_SET || 
+#                BITMAP_IS_SET(TABLE->READ_SET, FIELD_INDEX
+#
+CREATE TABLE t1(a INT);
+INSERT INTO t1 VALUES (0), (1);
+CREATE TABLE t2(
+b TEXT, 
+c INT, 
+PRIMARY KEY (b(1))
+);
+INSERT INTO t2 VALUES ('a', 2), ('b', 3);
+SELECT 1 FROM t1 WHERE a = 
+(SELECT 1 FROM t2 WHERE b = 
+(SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+ORDER BY b
+);
+1
+SELECT 1 FROM t1 WHERE a = 
+(SELECT 1 FROM t2 WHERE b = 
+(SELECT 1 FROM t1 t11 WHERE c = 1 OR t1.a = 1 AND 1 = 2)
+GROUP BY b
+);
+1
+DROP TABLE t1, t2;
 set optimizer_switch=default;

=== added file 'mysql-test/suite/binlog/r/binlog_reset_master.result'
--- a/mysql-test/suite/binlog/r/binlog_reset_master.result	1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/binlog/r/binlog_reset_master.result	2011-05-26 10:50:43 +0000
@@ -0,0 +1 @@
+RESET MASTER;

=== added file 'mysql-test/suite/binlog/t/binlog_reset_master.test'
--- a/mysql-test/suite/binlog/t/binlog_reset_master.test	1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/binlog/t/binlog_reset_master.test	2011-05-26 10:50:43 +0000
@@ -0,0 +1,26 @@
+# ==== Purpose ====
+#
+# Test bugs in RESET MASTER.
+
+--source include/have_debug.inc
+--source include/have_log_bin.inc
+
+#######################################################################
+# BUG#12574820: binlog.binlog_tmp_table timing out in daily and weekly trunk run
+# Problem: MYSQL_BIN_LOG::reset_logs acquired LOCK_thread_count and
+# LOCK_log in the wrong order. This could cause a deadlock when
+# RESET MASTER was run concurrently with a disconnecting thread.
+#######################################################################
+
+# We use sleep, not debug_sync, because the sync point needs to be in
+# the thread shut down code after the debug sync facility has been
+# shut down.
+--let $write_var= SET DEBUG="+d,sleep_after_lock_thread_count_before_delete_thd"; CREATE TEMPORARY TABLE test.t1 (a INT);
+--let $write_to_file= GENERATE
+--disable_query_log
+--source include/write_var_to_file.inc
+--enable_query_log
+
+--exec $MYSQL < $write_to_file
+RESET MASTER;
+--remove_file $write_to_file

=== modified file 'mysql-test/suite/innodb/r/innodb_mysql.result'
--- a/mysql-test/suite/innodb/r/innodb_mysql.result	2011-05-19 12:43:26 +0000
+++ b/mysql-test/suite/innodb/r/innodb_mysql.result	2011-05-26 16:23:52 +0000
@@ -2690,7 +2690,6 @@ COUNT(*)
 1537
 SET SESSION sort_buffer_size = DEFAULT;
 DROP TABLE t1;
-End of 5.1 tests
 #
 # Test for bug #39932 "create table fails if column for FK is in different
 #                      case than in corr index".
@@ -2712,6 +2711,23 @@ t2	CREATE TABLE `t2` (
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1
 drop table t2, t1;
 #
+# Test for bug #11762012 - "54553: INNODB ASSERTS IN HA_INNOBASE::
+#                           UPDATE_ROW, TEMPORARY TABLE, TABLE LOCK".
+#
+DROP TABLE IF EXISTS t1;
+CREATE TEMPORARY TABLE t1 (c int) ENGINE = InnoDB;
+INSERT INTO t1 VALUES (1);
+LOCK TABLES t1 READ;
+# Even though temporary table was locked for READ we
+# still allow writes to it to be compatible with MyISAM.
+# This is possible since due to fact that temporary tables
+# are specific to connection and therefore locking for them
+# is irrelevant.
+UPDATE t1 SET c = 5;
+UNLOCK TABLES;
+DROP TEMPORARY TABLE t1;
+End of 5.1 tests
+#
 # Bug#49604 "6.0 processing compound WHERE clause incorrectly 
 #            with Innodb - extra rows"
 #

=== modified file 'mysql-test/suite/innodb/t/innodb_mysql.test'
--- a/mysql-test/suite/innodb/t/innodb_mysql.test	2011-05-19 12:43:26 +0000
+++ b/mysql-test/suite/innodb/t/innodb_mysql.test	2011-05-26 16:23:52 +0000
@@ -830,8 +830,6 @@ SET SESSION sort_buffer_size = DEFAULT;
 
 DROP TABLE t1;
 
---echo End of 5.1 tests
-
 
 --echo #
 --echo # Test for bug #39932 "create table fails if column for FK is in different
@@ -852,6 +850,28 @@ drop table t2, t1;
 
 
 --echo #
+--echo # Test for bug #11762012 - "54553: INNODB ASSERTS IN HA_INNOBASE::
+--echo #                           UPDATE_ROW, TEMPORARY TABLE, TABLE LOCK".
+--echo #
+--disable_warnings
+DROP TABLE IF EXISTS t1;
+--enable_warnings
+CREATE TEMPORARY TABLE t1 (c int) ENGINE = InnoDB;
+INSERT INTO t1 VALUES (1);
+LOCK TABLES t1 READ;
+--echo # Even though temporary table was locked for READ we
+--echo # still allow writes to it to be compatible with MyISAM.
+--echo # This is possible since due to fact that temporary tables
+--echo # are specific to connection and therefore locking for them
+--echo # is irrelevant.
+UPDATE t1 SET c = 5;
+UNLOCK TABLES;
+DROP TEMPORARY TABLE t1;
+
+--echo End of 5.1 tests
+
+
+--echo #
 --echo # Bug#49604 "6.0 processing compound WHERE clause incorrectly 
 --echo #            with Innodb - extra rows"
 --echo #

=== added file 'mysql-test/suite/rpl/t/rpl_typeconv-master.opt'
--- a/mysql-test/suite/rpl/t/rpl_typeconv-master.opt	1970-01-01 00:00:00 +0000
+++ b/mysql-test/suite/rpl/t/rpl_typeconv-master.opt	2011-05-25 14:39:39 +0000
@@ -0,0 +1 @@
+--testcase-timeout=40

=== modified file 'mysql-test/t/func_math.test'
--- a/mysql-test/t/func_math.test	2011-04-20 07:56:57 +0000
+++ b/mysql-test/t/func_math.test	2011-05-26 10:13:07 +0000
@@ -370,6 +370,12 @@ DROP TABLE t1;
 
 SELECT ROUND(LEAST(15, -4939092, 0.2704), STDDEV('a'));
 
+--echo #
+--echo # Bug#12392636  ASSERTION FAILED: SCALE >= 0 && PRECISION > 0 && SCALE <= PRECISION
+--echo #
+
+SELECT SUM(DISTINCT (TRUNCATE((.1), NULL)));
+
 --echo End of 5.1 tests
 
 --echo #

=== modified file 'sql-common/client.c'
--- a/sql-common/client.c	2011-04-29 21:53:46 +0000
+++ b/sql-common/client.c	2011-05-26 12:36:57 +0000
@@ -1844,6 +1844,8 @@ mysql_get_ssl_cipher(MYSQL *mysql __attr
   ssl_verify_server_cert()
     vio              pointer to a SSL connected vio
     server_hostname  name of the server that we connected to
+    errptr           if we fail, we'll return (a pointer to a string
+                     describing) the reason here
 
   RETURN VALUES
    0 Success
@@ -1853,7 +1855,7 @@ mysql_get_ssl_cipher(MYSQL *mysql __attr
 
 #if defined(HAVE_OPENSSL) && !defined(EMBEDDED_LIBRARY)
 
-static int ssl_verify_server_cert(Vio *vio, const char* server_hostname)
+static int ssl_verify_server_cert(Vio *vio, const char* server_hostname, const char **errptr)
 {
   SSL *ssl;
   X509 *server_cert;
@@ -1864,19 +1866,19 @@ static int ssl_verify_server_cert(Vio *v
 
   if (!(ssl= (SSL*)vio->ssl_arg))
   {
-    DBUG_PRINT("error", ("No SSL pointer found"));
+    *errptr= "No SSL pointer found";
     DBUG_RETURN(1);
   }
 
   if (!server_hostname)
   {
-    DBUG_PRINT("error", ("No server hostname supplied"));
+    *errptr= "No server hostname supplied";
     DBUG_RETURN(1);
   }
 
   if (!(server_cert= SSL_get_peer_certificate(ssl)))
   {
-    DBUG_PRINT("error", ("Could not get server certificate"));
+    *errptr= "Could not get server certificate";
     DBUG_RETURN(1);
   }
 
@@ -1905,7 +1907,7 @@ static int ssl_verify_server_cert(Vio *v
       DBUG_RETURN(0);
     }
   }
-  DBUG_PRINT("error", ("SSL certificate validation failure"));
+  *errptr= "SSL certificate validation failure";
   DBUG_RETURN(1);
 }
 
@@ -2511,6 +2513,9 @@ static int send_client_reply_packet(MCPV
     /* Do the SSL layering. */
     struct st_mysql_options *options= &mysql->options;
     struct st_VioSSLFd *ssl_fd;
+    enum enum_ssl_init_error ssl_init_error;
+    const char *cert_error;
+    unsigned long ssl_error;
 
     /*
       Send mysql->client_flag, max_packet_size - unencrypted otherwise
@@ -2530,9 +2535,11 @@ static int send_client_reply_packet(MCPV
                                         options->ssl_cert,
                                         options->ssl_ca,
                                         options->ssl_capath,
-                                        options->ssl_cipher)))
+                                        options->ssl_cipher,
+                                        &ssl_init_error)))
     {
-      set_mysql_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate);
+      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
+                               ER(CR_SSL_CONNECTION_ERROR), sslGetErrString(ssl_init_error));
       goto error;
     }
     mysql->connector_fd= (unsigned char *) ssl_fd;
@@ -2540,18 +2547,24 @@ static int send_client_reply_packet(MCPV
     /* Connect to the server */
     DBUG_PRINT("info", ("IO layer change in progress..."));
     if (sslconnect(ssl_fd, net->vio,
-                   (long) (mysql->options.connect_timeout)))
+                   (long) (mysql->options.connect_timeout), &ssl_error))
     {    
-      set_mysql_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate);
+      char buf[512];
+      ERR_error_string_n(ssl_error, buf, 512);
+      buf[511]= 0;
+      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
+                               ER(CR_SSL_CONNECTION_ERROR),
+                               buf);
       goto error;
     }    
     DBUG_PRINT("info", ("IO layer change done!"));
 
     /* Verify server cert */
     if ((mysql->client_flag & CLIENT_SSL_VERIFY_SERVER_CERT) &&
-        ssl_verify_server_cert(net->vio, mysql->host))
+        ssl_verify_server_cert(net->vio, mysql->host, &cert_error))
     {
-      set_mysql_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate);
+      set_mysql_extended_error(mysql, CR_SSL_CONNECTION_ERROR, unknown_sqlstate,
+                               ER(CR_SSL_CONNECTION_ERROR), cert_error);
       goto error;
     }
   }

=== modified file 'sql/binlog.cc'
--- a/sql/binlog.cc	2011-05-12 17:29:19 +0000
+++ b/sql/binlog.cc	2011-05-26 11:18:45 +0000
@@ -2315,12 +2315,6 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
   DBUG_ENTER("reset_logs");
 
   ha_reset_logs(thd);
-  /*
-    We need to get both locks to be sure that no one is trying to
-    write to the index log file.
-  */
-  mysql_mutex_lock(&LOCK_log);
-  mysql_mutex_lock(&LOCK_index);
 
   /*
     The following mutex is needed to ensure that no threads call
@@ -2330,6 +2324,13 @@ bool MYSQL_BIN_LOG::reset_logs(THD* thd)
   */
   mysql_mutex_lock(&LOCK_thread_count);
 
+  /*
+    We need to get both locks to be sure that no one is trying to
+    write to the index log file.
+  */
+  mysql_mutex_lock(&LOCK_log);
+  mysql_mutex_lock(&LOCK_index);
+
   /* Save variables so that we can reopen the log */
   save_name=name;
   name=0;					// Protect against free

=== modified file 'sql/item_func.cc'
--- a/sql/item_func.cc	2011-05-21 09:31:19 +0000
+++ b/sql/item_func.cc	2011-05-26 10:13:07 +0000
@@ -2273,6 +2273,9 @@ void Item_func_round::fix_length_and_dec
   }
 
   val1= args[1]->val_int();
+  if ((null_value= args[1]->is_null()))
+    return;
+
   val1_unsigned= args[1]->unsigned_flag;
   if (val1 < 0)
     decimals_to_set= val1_unsigned ? INT_MAX : 0;

=== modified file 'sql/item_subselect.cc'
--- a/sql/item_subselect.cc	2011-04-06 11:13:33 +0000
+++ b/sql/item_subselect.cc	2011-05-24 09:36:11 +0000
@@ -3181,23 +3181,24 @@ bool subselect_hash_sj_engine::setup(Lis
     - here we initialize only those members that are used by
       subselect_uniquesubquery_engine, so these objects are incomplete.
   */ 
-  if (!(tab= new (thd->mem_root) JOIN_TAB))
+  JOIN_TAB * const tmp_tab= new (thd->mem_root) JOIN_TAB;
+  if (tmp_tab == NULL)
     DBUG_RETURN(TRUE);
-  tab->table= tmp_table;
-  tab->ref.key= 0; /* The only temp table index. */
-  tab->ref.key_length= tmp_key->key_length;
-  if (!(tab->ref.key_buff=
+  tmp_tab->table= tmp_table;
+  tmp_tab->ref.key= 0; /* The only temp table index. */
+  tmp_tab->ref.key_length= tmp_key->key_length;
+  if (!(tmp_tab->ref.key_buff=
         (uchar*) thd->calloc(ALIGN_SIZE(tmp_key->key_length) * 2)) ||
-      !(tab->ref.key_copy=
+      !(tmp_tab->ref.key_copy=
         (store_key**) thd->alloc((sizeof(store_key*) *
                                   (tmp_key_parts + 1)))) ||
-      !(tab->ref.items=
+      !(tmp_tab->ref.items=
         (Item**) thd->alloc(sizeof(Item*) * tmp_key_parts)))
     DBUG_RETURN(TRUE);
 
   KEY_PART_INFO *cur_key_part= tmp_key->key_part;
-  store_key **ref_key= tab->ref.key_copy;
-  uchar *cur_ref_buff= tab->ref.key_buff;
+  store_key **ref_key= tmp_tab->ref.key_copy;
+  uchar *cur_ref_buff= tmp_tab->ref.key_buff;
 
   /*
     Create an artificial condition to post-filter those rows matched by index
@@ -3235,10 +3236,10 @@ bool subselect_hash_sj_engine::setup(Lis
     /* Item for the corresponding field from the materialized temp table. */
     Item_field *right_col_item;
     int null_count= test(cur_key_part->field->real_maybe_null());
-    tab->ref.items[i]= item_in->left_expr->element_index(i);
+    tmp_tab->ref.items[i]= item_in->left_expr->element_index(i);
 
     if (!(right_col_item= new Item_field(thd, context, cur_key_part->field)) ||
-        !(eq_cond= new Item_func_eq(tab->ref.items[i], right_col_item)) ||
+        !(eq_cond= new Item_func_eq(tmp_tab->ref.items[i], right_col_item)) ||
         ((Item_cond_and*)cond)->add(eq_cond))
     {
       delete cond;
@@ -3255,16 +3256,19 @@ bool subselect_hash_sj_engine::setup(Lis
                                  */
                                  cur_ref_buff + null_count,
                                  null_count ? cur_ref_buff : 0,
-                                 cur_key_part->length, tab->ref.items[i]);
+                                 cur_key_part->length, tmp_tab->ref.items[i]);
     cur_ref_buff+= cur_key_part->store_length;
   }
   *ref_key= NULL; /* End marker. */
-  tab->ref.key_err= 1;
-  tab->ref.key_parts= tmp_key_parts;
+  tmp_tab->ref.key_err= 1;
+  tmp_tab->ref.key_parts= tmp_key_parts;
 
   if (cond->fix_fields(thd, &cond))
     DBUG_RETURN(TRUE);
 
+  // Set 'tab' only when function cannot fail, because of assert in destructor
+  tab= tmp_tab;
+
   /*
     Create and optimize the JOIN that will be used to materialize
     the subquery if not yet created.

=== modified file 'sql/mysqld.cc'
--- a/sql/mysqld.cc	2011-05-25 10:18:08 +0000
+++ b/sql/mysqld.cc	2011-05-26 11:18:45 +0000
@@ -2081,6 +2081,12 @@ void unlink_thd(THD *thd)
   thd_cleanup(thd);
   dec_connection_count();
   mysql_mutex_lock(&LOCK_thread_count);
+  /*
+    Used by binlog_reset_master.  It would be cleaner to use
+    DEBUG_SYNC here, but that's not possible because the THD's debug
+    sync feature has been shut down at this point.
+  */
+  DBUG_EXECUTE_IF("sleep_after_lock_thread_count_before_delete_thd", sleep(5););
   delete_thd(thd);
   DBUG_VOID_RETURN;
 }

=== modified file 'sql/sql_acl.cc'
--- a/sql/sql_acl.cc	2011-05-21 08:25:33 +0000
+++ b/sql/sql_acl.cc	2011-05-26 12:36:57 +0000
@@ -8608,14 +8608,14 @@ static ulong parse_client_handshake_pack
   DBUG_PRINT("info", ("client capabilities: %lu", mpvio->client_capabilities));
   if (mpvio->client_capabilities & CLIENT_SSL)
   {
-    char error_string[1024] __attribute__((unused));
+    unsigned long errptr;
 
     /* Do the SSL layering. */
     if (!ssl_acceptor_fd)
       return packet_error;
 
     DBUG_PRINT("info", ("IO layer change in progress..."));
-    if (sslaccept(ssl_acceptor_fd, net->vio, net->read_timeout))
+    if (sslaccept(ssl_acceptor_fd, net->vio, net->read_timeout, &errptr))
     {
       DBUG_PRINT("error", ("Failed to accept new SSL connection"));
       return packet_error;

=== modified file 'sql/sql_array.h'
--- a/sql/sql_array.h	2010-11-05 22:14:29 +0000
+++ b/sql/sql_array.h	2011-05-18 13:12:02 +0000
@@ -79,75 +79,4 @@ public:
   }
 };
 
-
-/* 
-  Array of pointers to Elem that uses memory from MEM_ROOT
-
-  MEM_ROOT has no realloc() so this is supposed to be used for cases when
-  reallocations are rare.
-*/
-
-template <class Elem> class Array
-{
-  enum {alloc_increment = 16};
-  Elem **buffer;
-  uint n_elements, max_element;
-public:
-  Array(MEM_ROOT *mem_root, uint prealloc=16)
-  {
-    buffer= (Elem**)alloc_root(mem_root, prealloc * sizeof(Elem**));
-    max_element = buffer? prealloc : 0;
-    n_elements= 0;
-  }
-
-  Elem& at(int idx)
-  {
-    return *(((Elem*)buffer) + idx);
-  }
-
-  Elem **front()
-  {
-    return buffer;
-  }
-
-  Elem **back()
-  {
-    return buffer + n_elements;
-  }
-
-  bool append(MEM_ROOT *mem_root, Elem *el)
-  {
-    if (n_elements == max_element)
-    {
-      Elem **newbuf;
-      if (!(newbuf= (Elem**)alloc_root(mem_root, (n_elements + alloc_increment)*
-                                                  sizeof(Elem**))))
-      {
-        return FALSE;
-      }
-      memcpy(newbuf, buffer, n_elements*sizeof(Elem*));
-      buffer= newbuf;
-    }
-    buffer[n_elements++]= el;
-    return FALSE;
-  }
-
-  int elements()
-  {
-    return n_elements;
-  }
-
-  void clear()
-  {
-    n_elements= 0;
-  }
-
-  typedef int (*CMP_FUNC)(Elem * const *el1, Elem *const *el2);
-
-  void sort(CMP_FUNC cmp_func)
-  {
-    my_qsort(buffer, n_elements, sizeof(Elem*), (qsort_cmp)cmp_func);
-  }
-};
-
 #endif /* SQL_ARRAY_INCLUDED */

=== modified file 'sql/sql_base.cc'
--- a/sql/sql_base.cc	2011-05-21 08:25:33 +0000
+++ b/sql/sql_base.cc	2011-05-26 08:39:40 +0000
@@ -6876,9 +6876,29 @@ find_field_in_tables(THD *thd, Item_iden
   if (last_table)
     last_table= last_table->next_name_resolution_table;
 
+#ifndef DBUG_OFF
+  uint loop_count= 0;
+  TABLE_LIST *one_node;
+#endif
   for (; cur_table != last_table ;
        cur_table= cur_table->next_name_resolution_table)
   {
+#ifndef DBUG_OFF
+    ++loop_count;
+    if (loop_count == 1000) // not normal, record one node we meet
+      one_node= cur_table;
+    if ((loop_count > 1000) && (one_node == cur_table))
+    {
+      /*
+        Meeting same node again: cycle, infinite loop. Raise an error which
+        doesn't stop RQG, so that Roel can continue working while we fix the
+        bug. We cannot continue the statement though.
+      */
+      my_error(ER_WRONG_FIELD_WITH_GROUP, MYF(0),
+               "HITTING BUG#12567331 INFINITE LOOP DETECTED - ASK GUILHEM AND ROEL");
+      return NULL;
+    }
+#endif
     Field *cur_field= find_field_in_table_ref(thd, cur_table, name, length,
                                               item->name, db, table_name, ref,
                                               (thd->lex->sql_command ==

=== modified file 'sql/sql_parse.cc'
--- a/sql/sql_parse.cc	2011-05-21 08:25:33 +0000
+++ b/sql/sql_parse.cc	2011-05-26 16:23:52 +0000
@@ -1891,6 +1891,67 @@ bool sp_process_definer(THD *thd)
 
 
 /**
+  Auxiliary call that opens and locks tables for LOCK TABLES statement
+  and initializes the list of locked tables.
+
+  @param thd     Thread context.
+  @param tables  List of tables to be locked.
+
+  @return FALSE in case of success, TRUE in case of error.
+*/
+
+static bool lock_tables_open_and_lock_tables(THD *thd, TABLE_LIST *tables)
+{
+  Lock_tables_prelocking_strategy lock_tables_prelocking_strategy;
+  uint counter;
+  TABLE_LIST *table;
+
+  thd->in_lock_tables= 1;
+
+  if (open_tables(thd, &tables, &counter, 0, &lock_tables_prelocking_strategy))
+    goto err;
+
+  /*
+    We allow to change temporary tables even if they were locked for read
+    by LOCK TABLES. To avoid a discrepancy between lock acquired at LOCK
+    TABLES time and by the statement which is later executed under LOCK TABLES
+    we ensure that for temporary tables we always request a write lock (such
+    discrepancy can cause problems for the storage engine).
+    We don't set TABLE_LIST::lock_type in this case as this might result in
+    extra warnings from THD::decide_logging_format() even though binary logging
+    is totally irrelevant for LOCK TABLES.
+  */
+  for (table= tables; table; table= table->next_global)
+    if (!table->placeholder() && table->table->s->tmp_table)
+      table->table->reginfo.lock_type= TL_WRITE;
+
+  if (lock_tables(thd, tables, counter, 0) ||
+      thd->locked_tables_list.init_locked_tables(thd))
+    goto err;
+
+  thd->in_lock_tables= 0;
+
+  return FALSE;
+
+err:
+  thd->in_lock_tables= 0;
+
+  trans_rollback_stmt(thd);
+  /*
+    Need to end the current transaction, so the storage engine (InnoDB)
+    can free its locks if LOCK TABLES locked some tables before finding
+    that it can't lock a table in its list
+  */
+  trans_commit_implicit(thd);
+  /* Close tables and release metadata locks. */
+  close_thread_tables(thd);
+  DBUG_ASSERT(!thd->locked_tables_mode);
+  thd->mdl_context.release_transactional_locks();
+  return TRUE;
+}
+
+
+/**
   Execute command saved in thd and lex->sql_command.
 
   @param thd                       Thread handle
@@ -3265,31 +3326,11 @@ end_with_restore_list:
       goto error;
 
     thd->variables.option_bits|= OPTION_TABLE_LOCK;
-    thd->in_lock_tables=1;
 
-    {
-      Lock_tables_prelocking_strategy lock_tables_prelocking_strategy;
-
-      res= (open_and_lock_tables(thd, all_tables, FALSE, 0,
-                                 &lock_tables_prelocking_strategy) ||
-            thd->locked_tables_list.init_locked_tables(thd));
-    }
-
-    thd->in_lock_tables= 0;
+    res= lock_tables_open_and_lock_tables(thd, all_tables);
 
     if (res)
     {
-      trans_rollback_stmt(thd);
-      /*
-        Need to end the current transaction, so the storage engine (InnoDB)
-        can free its locks if LOCK TABLES locked some tables before finding
-        that it can't lock a table in its list
-      */
-      trans_commit_implicit(thd);
-      /* Close tables and release metadata locks. */
-      close_thread_tables(thd);
-      DBUG_ASSERT(!thd->locked_tables_mode);
-      thd->mdl_context.release_transactional_locks();
       thd->variables.option_bits&= ~(OPTION_TABLE_LOCK);
     }
     else

=== modified file 'sql/sql_select.cc'
--- a/sql/sql_select.cc	2011-05-18 10:43:46 +0000
+++ b/sql/sql_select.cc	2011-05-26 11:09:57 +0000
@@ -978,7 +978,7 @@ bool resolve_subquery(THD *thd, JOIN *jo
 
     /* Register the subquery for further processing in flatten_subqueries() */
     select_lex->outer_select()->join->
-      sj_subselects.append(thd->mem_root, in_exists_predicate);
+      sj_subselects.push_back(in_exists_predicate);
   }
   else
   {
@@ -1904,6 +1904,11 @@ JOIN::optimize()
       thd->restore_active_arena(arena, &backup);
   }
 
+  /*
+    Note: optimize_cond() makes changes to conds. Since
+    select_lex->where and conds points to the same condition, this
+    function call effectively changes select_lex->where as well.
+  */
   conds= optimize_cond(this, conds, join_list, TRUE, &select_lex->cond_value);
   if (thd->is_error())
   {
@@ -1913,6 +1918,7 @@ JOIN::optimize()
   }
 
   {
+    // Note above about optimize_cond() also applies to selec_lex->having
     having= optimize_cond(this, having, join_list, FALSE,
                           &select_lex->having_value);
     if (thd->is_error())
@@ -4170,11 +4176,11 @@ bool JOIN::flatten_subqueries()
   Item_exists_subselect **subq_end;
   DBUG_ENTER("JOIN::flatten_subqueries");
 
-  if (sj_subselects.elements() == 0)
+  if (sj_subselects.empty())
     DBUG_RETURN(FALSE);
 
   /* First, convert child join's subqueries. We proceed bottom-up here */
-  for (subq= sj_subselects.front(), subq_end= sj_subselects.back(); 
+  for (subq= sj_subselects.begin(), subq_end= sj_subselects.end(); 
        subq != subq_end;
        subq++)
   {
@@ -4207,7 +4213,7 @@ bool JOIN::flatten_subqueries()
   {
     if (tbl->on_expr || tbl->in_outer_join_nest())
     {
-      subq= sj_subselects.front();
+      subq= sj_subselects.begin();
       arena= thd->activate_stmt_arena_if_needed(&backup);
       goto skip_conversion;
     }
@@ -4220,11 +4226,14 @@ bool JOIN::flatten_subqueries()
       - prefer correlated subqueries over uncorrelated;
       - prefer subqueries that have greater number of outer tables;
   */
-  sj_subselects.sort(subq_sj_candidate_cmp);
+  my_qsort(sj_subselects.begin(),
+           sj_subselects.size(), sj_subselects.element_size(),
+           reinterpret_cast<qsort_cmp>(subq_sj_candidate_cmp));
+
   // #tables-in-parent-query + #tables-in-subquery < MAX_TABLES
   /* Replace all subqueries to be flattened with Item_int(1) */
   arena= thd->activate_stmt_arena_if_needed(&backup);
-  for (subq= sj_subselects.front(); 
+  for (subq= sj_subselects.begin(); 
        subq != subq_end && 
        tables + (*subq)->unit->first_select()->join->tables < MAX_TABLES;
        subq++)
@@ -4235,7 +4244,7 @@ bool JOIN::flatten_subqueries()
       DBUG_RETURN(TRUE); /* purecov: inspected */
   }
  
-  for (subq= sj_subselects.front(); 
+  for (subq= sj_subselects.begin(); 
        subq != subq_end && 
        tables + (*subq)->unit->first_select()->join->tables < MAX_TABLES;
        subq++)
@@ -14708,7 +14717,8 @@ optimize_cond(JOIN *join, Item *conds, L
   SYNPOSIS
     remove_eq_conds()
     thd 			THD environment
-    cond                        the condition to handle
+    cond                        the condition to handle. Note that cond
+                                is changed by this function
     cond_value                  the resulting value of the condition
 
   RETURN
@@ -14770,9 +14780,34 @@ internal_remove_eq_conds(THD *thd, Item 
 	*cond_value != Item::COND_OK)
       return (Item*) 0;
     if (((Item_cond*) cond)->argument_list()->elements == 1)
-    {						// Remove list
+    {
+      /*
+        BUG#11765699:
+        We're dealing with an AND or OR item that has only one
+        argument. However, it is not an option to empty the list
+        because:
+
+         - this function is called for either JOIN::conds or
+           JOIN::having, but these point to the same condition as
+           SELECT_LEX::where and SELECT_LEX::having do.
+
+         - The return value of remove_eq_conds() is assigned to
+           JOIN::conds and JOIN::having, so emptying the list and
+           returning the only remaining item "replaces" the AND or OR
+           with item for the variables in JOIN. However, the return
+           value is not assigned to the SELECT_LEX counterparts. Thus,
+           if argument_list is emptied, SELECT_LEX forgets the item in
+           argument_list()->head().
+
+        item is therefore returned, but argument_list is not emptied.
+      */
       item= ((Item_cond*) cond)->argument_list()->head();
-      ((Item_cond*) cond)->argument_list()->empty();
+      /*
+        Consider reenabling the line below when the optimizer has been
+        split into properly separated phases.
+ 
+        ((Item_cond*) cond)->argument_list()->empty();
+      */
       return item;
     }
   }

=== modified file 'sql/sql_select.h'
--- a/sql/sql_select.h	2011-05-18 10:43:46 +0000
+++ b/sql/sql_select.h	2011-05-26 06:03:02 +0000
@@ -1888,7 +1888,8 @@ public:
   bool union_part; ///< this subselect is part of union 
   bool optimized; ///< flag to avoid double optimization in EXPLAIN
   
-  Array<Item_exists_subselect> sj_subselects;
+  // true: No need to run DTORs on pointers.
+  Mem_root_array<Item_exists_subselect*, true> sj_subselects;
 
   /* Temporary tables used to weed-out semi-join duplicates */
   List<TABLE> sj_tmp_tables;
@@ -1913,7 +1914,7 @@ public:
        select_result *result_arg)
     : keyuse(thd_arg->mem_root),
       fields_list(fields_arg),
-      sj_subselects(thd_arg->mem_root, 4)
+      sj_subselects(thd_arg->mem_root)
   {
     init(thd_arg, fields_arg, select_options_arg, result_arg);
   }

=== modified file 'storage/innobase/handler/i_s.cc'
--- a/storage/innobase/handler/i_s.cc	2011-05-21 08:25:33 +0000
+++ b/storage/innobase/handler/i_s.cc	2011-05-25 13:43:30 +0000
@@ -3347,7 +3347,7 @@ i_s_innodb_buffer_page_get_info(
 
 		page_info->space_id = buf_page_get_space(bpage);
 
-		page_info->page_num = buf_page_get_page_no(bpage);;
+		page_info->page_num = buf_page_get_page_no(bpage);
 
 		page_info->flush_type = bpage->flush_type;
 
@@ -4793,7 +4793,7 @@ i_s_sys_indexes_fill_table(
 
 	/* Process each record in the table */
 	while (rec) {
-		const char*	err_msg;;
+		const char*	err_msg;
 		table_id_t	table_id;
 		dict_index_t	index_rec;
 

=== modified file 'storage/innobase/lock/lock0lock.c'
--- a/storage/innobase/lock/lock0lock.c	2011-05-24 20:22:08 +0000
+++ b/storage/innobase/lock/lock0lock.c	2011-05-27 03:36:33 +0000
@@ -4393,7 +4393,11 @@ lock_trx_table_locks_remove(
 
 	ut_ad(lock_mutex_own());
 
-	trx_mutex_enter(trx);
+	if (!trx->lock.was_chosen_as_deadlock_victim) {
+		trx_mutex_enter(trx);
+	} else {
+		ut_ad(trx_mutex_own(trx));
+	}
 
 	for (i = ib_vector_size(trx->lock.table_locks) - 1; i >= 0; --i) {
 		const lock_t*	lock;
@@ -4410,12 +4414,18 @@ lock_trx_table_locks_remove(
 
 		if (lock == lock_to_remove) {
 			ib_vector_set(trx->lock.table_locks, i, NULL);
-			trx_mutex_exit(trx);
+
+			if (!trx->lock.was_chosen_as_deadlock_victim) {
+				trx_mutex_exit(trx);
+			}
+
 			return;
 		}
 	}
 
-	trx_mutex_exit(trx);
+	if (!trx->lock.was_chosen_as_deadlock_victim) {
+		trx_mutex_exit(trx);
+	}
 
 	/* Lock must exist in the vector. */
 	ut_error;

=== modified file 'storage/innobase/que/que0que.c'
--- a/storage/innobase/que/que0que.c	2011-04-12 07:53:47 +0000
+++ b/storage/innobase/que/que0que.c	2011-05-25 13:43:30 +0000
@@ -703,7 +703,7 @@ que_thr_stop(
 	que_thr_t*	thr)	/*!< in: query thread */
 {
 	que_t*		graph;
-	trx_t*		trx = thr_get_trx(thr);;
+	trx_t*		trx = thr_get_trx(thr);
 
 	graph = thr->graph;
 

=== modified file 'storage/innobase/srv/srv0start.c'
--- a/storage/innobase/srv/srv0start.c	2011-05-17 11:42:10 +0000
+++ b/storage/innobase/srv/srv0start.c	2011-05-26 06:29:48 +0000
@@ -840,7 +840,8 @@ open_or_create_data_files(
 			ut_a(size != (os_offset_t) -1);
 			/* Round size downward to megabytes */
 
-			rounded_size_pages = size >> UNIV_PAGE_SIZE_SHIFT;
+			rounded_size_pages = (ulint)
+				(size >> UNIV_PAGE_SIZE_SHIFT);
 
 			if (i == srv_n_data_files - 1
 			    && srv_auto_extend_last_data_file) {

=== modified file 'vio/test-ssl.c'
--- a/vio/test-ssl.c	2010-07-15 11:13:30 +0000
+++ b/vio/test-ssl.c	2011-05-19 09:47:43 +0000
@@ -59,6 +59,9 @@ main(int argc, char**	argv)
   struct st_VioSSLFd* ssl_acceptor= 0;
   struct st_VioSSLFd* ssl_connector= 0;
   Vio* client_vio=0, *server_vio=0;
+  enum enum_ssl_init_error ssl_init_error;
+  unsigned long ssl_error;
+
   MY_INIT(argv[0]);
   DBUG_PROCESS(argv[0]);
   DBUG_PUSH(default_dbug_option);
@@ -91,16 +94,16 @@ main(int argc, char**	argv)
   ssl_acceptor = new_VioSSLAcceptorFd(server_key, server_cert, ca_file,
 				      ca_path, cipher);
   ssl_connector = new_VioSSLConnectorFd(client_key, client_cert, ca_file,
-					ca_path, cipher);
+					ca_path, cipher, &ssl_init_error);
 
   client_vio = (struct st_vio*)my_malloc(sizeof(struct st_vio),MYF(0));
   client_vio->sd = sv[0];
   client_vio->vioblocking(client_vio, 0, &unused);
-  sslconnect(ssl_connector,client_vio,60L);
+  sslconnect(ssl_connector,client_vio,60L,&ssl_error);
   server_vio = (struct st_vio*)my_malloc(sizeof(struct st_vio),MYF(0));
   server_vio->sd = sv[1];
   server_vio->vioblocking(client_vio, 0, &unused);
-  sslaccept(ssl_acceptor,server_vio,60L);
+  sslaccept(ssl_acceptor,server_vio,60L, &ssl_error);
 
   printf("Socketpair: %d , %d\n", client_vio->sd, server_vio->sd);
 

=== modified file 'vio/test-sslclient.c'
--- a/vio/test-sslclient.c	2010-07-08 21:20:08 +0000
+++ b/vio/test-sslclient.c	2011-05-19 09:47:43 +0000
@@ -50,6 +50,9 @@ main(	int	argc __attribute__((unused)),
 	Vio* client_vio=0;
 	int err;
 	char	xbuf[100]="Ohohhhhoh1234";
+        enum enum_ssl_init_error ssl_init_error;
+        unsigned long ssl_error;
+
 	MY_INIT(argv[0]);
         DBUG_PROCESS(argv[0]);
         DBUG_PUSH(default_dbug_option);
@@ -60,7 +63,8 @@ main(	int	argc __attribute__((unused)),
 	if (ca_path!=0)
 		printf("CApath          : %s\n", ca_path);
 
-	ssl_connector = new_VioSSLConnectorFd(client_key, client_cert, ca_file, ca_path, cipher);
+	ssl_connector = new_VioSSLConnectorFd(client_key, client_cert, ca_file, ca_path, cipher,
+                                              &ssl_init_error);
 	if(!ssl_connector) {
                  fatal_error("client:new_VioSSLConnectorFd failed");
 	}
@@ -81,7 +85,7 @@ main(	int	argc __attribute__((unused)),
 	/* ----------------------------------------------- */
 	/* Now we have TCP conncetion. Start SSL negotiation. */
 	read(client_vio->sd,xbuf, sizeof(xbuf));
-        sslconnect(ssl_connector,client_vio,60L);
+        sslconnect(ssl_connector,client_vio,60L,&ssl_error);
 	err = vio_read(client_vio,xbuf, sizeof(xbuf));
 	if (err<=0) {
 		my_free(ssl_connector);

=== modified file 'vio/test-sslserver.c'
--- a/vio/test-sslserver.c	2010-07-08 21:20:08 +0000
+++ b/vio/test-sslserver.c	2011-05-19 09:47:43 +0000
@@ -52,6 +52,7 @@ do_ssl_stuff(	TH_ARGS*	args)
 	const char*	s = "Huhuhuhuuu";
 	Vio*		server_vio;
 	int		err;
+        unsigned long   ssl_error;
 	DBUG_ENTER("do_ssl_stuff");
 
 	server_vio = vio_new(args->sd, VIO_TYPE_TCPIP, TRUE);
@@ -60,7 +61,7 @@ do_ssl_stuff(	TH_ARGS*	args)
 	/* TCP connection is ready. Do server side SSL. */
 
 	err = write(server_vio->sd,(uchar*)s, strlen(s));
-	sslaccept(args->ssl_acceptor,server_vio,60L);
+	sslaccept(args->ssl_acceptor,server_vio,60L,&ssl_error);
 	err = server_vio->write(server_vio,(uchar*)s, strlen(s));
 	DBUG_VOID_RETURN;
 }

=== modified file 'vio/viossl.c'
--- a/vio/viossl.c	2010-08-16 12:50:27 +0000
+++ b/vio/viossl.c	2011-05-19 09:47:43 +0000
@@ -144,8 +144,9 @@ void vio_ssl_delete(Vio *vio)
 
 
 static int ssl_do(struct st_VioSSLFd *ptr, Vio *vio, long timeout,
-                  int (*connect_accept_func)(SSL*))
+                  int (*connect_accept_func)(SSL*), unsigned long *errptr)
 {
+  int r;
   SSL *ssl;
   my_bool unused;
   my_bool was_blocking;
@@ -160,7 +161,7 @@ static int ssl_do(struct st_VioSSLFd *pt
   if (!(ssl= SSL_new(ptr->ssl_context)))
   {
     DBUG_PRINT("error", ("SSL_new failure"));
-    report_errors(ssl);
+    *errptr= ERR_get_error();
     vio_blocking(vio, was_blocking, &unused);
     DBUG_RETURN(1);
   }
@@ -169,10 +170,10 @@ static int ssl_do(struct st_VioSSLFd *pt
   SSL_SESSION_set_timeout(SSL_get_session(ssl), timeout);
   SSL_set_fd(ssl, vio->sd);
 
-  if (connect_accept_func(ssl) < 1)
+  if ((r= connect_accept_func(ssl)) < 1)
   {
     DBUG_PRINT("error", ("SSL_connect/accept failure"));
-    report_errors(ssl);
+    *errptr= SSL_get_error(ssl, r);
     SSL_free(ssl);
     vio_blocking(vio, was_blocking, &unused);
     DBUG_RETURN(1);
@@ -220,17 +221,17 @@ static int ssl_do(struct st_VioSSLFd *pt
 }
 
 
-int sslaccept(struct st_VioSSLFd *ptr, Vio *vio, long timeout)
+int sslaccept(struct st_VioSSLFd *ptr, Vio *vio, long timeout, unsigned long *errptr)
 {
   DBUG_ENTER("sslaccept");
-  DBUG_RETURN(ssl_do(ptr, vio, timeout, SSL_accept));
+  DBUG_RETURN(ssl_do(ptr, vio, timeout, SSL_accept, errptr));
 }
 
 
-int sslconnect(struct st_VioSSLFd *ptr, Vio *vio, long timeout)
+int sslconnect(struct st_VioSSLFd *ptr, Vio *vio, long timeout, unsigned long *errptr)
 {
   DBUG_ENTER("sslconnect");
-  DBUG_RETURN(ssl_do(ptr, vio, timeout, SSL_connect));
+  DBUG_RETURN(ssl_do(ptr, vio, timeout, SSL_connect, errptr));
 }
 
 

=== modified file 'vio/viosslfactories.c'
--- a/vio/viosslfactories.c	2010-07-15 11:13:30 +0000
+++ b/vio/viosslfactories.c	2011-05-19 09:47:43 +0000
@@ -165,7 +165,7 @@ static struct st_VioSSLFd *
 new_VioSSLFd(const char *key_file, const char *cert_file,
              const char *ca_file, const char *ca_path,
              const char *cipher, SSL_METHOD *method, 
-             enum enum_ssl_init_error* error)
+             enum enum_ssl_init_error *error)
 {
   DH *dh;
   struct st_VioSSLFd *ssl_fd;
@@ -249,11 +249,10 @@ new_VioSSLFd(const char *key_file, const
 struct st_VioSSLFd *
 new_VioSSLConnectorFd(const char *key_file, const char *cert_file,
                       const char *ca_file, const char *ca_path,
-                      const char *cipher)
+                      const char *cipher, enum enum_ssl_init_error* error)
 {
   struct st_VioSSLFd *ssl_fd;
   int verify= SSL_VERIFY_PEER;
-  enum enum_ssl_init_error dummy;
 
   /*
     Turn off verification of servers certificate if both
@@ -263,7 +262,7 @@ new_VioSSLConnectorFd(const char *key_fi
     verify= SSL_VERIFY_NONE;
 
   if (!(ssl_fd= new_VioSSLFd(key_file, cert_file, ca_file,
-                             ca_path, cipher, TLSv1_client_method(), &dummy)))
+                             ca_path, cipher, TLSv1_client_method(), error)))
   {
     return 0;
   }

=== modified file 'vio/viotest-ssl.c'
--- a/vio/viotest-ssl.c	2010-07-08 21:20:08 +0000
+++ b/vio/viotest-ssl.c	2011-05-19 09:47:43 +0000
@@ -60,6 +60,9 @@ int main(int argc, char **argv)
   struct st_VioSSLConnectorFd* ssl_connector=0; 
   Vio* client_vio=0;
   Vio* server_vio=0;
+  enum enum_ssl_init_error ssl_init_error;
+  unsigned long ssl_error;
+
   MY_INIT(argv[0]);
   DBUG_PROCESS(argv[0]);
   DBUG_PUSH(default_dbug_option);
@@ -92,14 +95,14 @@ int main(int argc, char **argv)
   ssl_acceptor = new_VioSSLAcceptorFd(server_key, server_cert, ca_file,
 				      ca_path);
   ssl_connector = new_VioSSLConnectorFd(client_key, client_cert, ca_file,
-					ca_path);
+					ca_path, &ssl_init_error);
 
   client_vio = (Vio*)my_malloc(sizeof(struct st_vio),MYF(0));
   client_vio->sd = sv[0];
-  sslconnect(ssl_connector,client_vio);
+  sslconnect(ssl_connector,client_vio,&ssl_error);
   server_vio = (Vio*)my_malloc(sizeof(struct st_vio),MYF(0));
   server_vio->sd = sv[1];
-  sslaccept(ssl_acceptor,server_vio);
+  sslaccept(ssl_acceptor,server_vio,&ssl_error);
 
   printf("Socketpair: %d , %d\n", client_vio->sd, server_vio->sd);
 


--===============1763045711==
MIME-Version: 1.0
Content-Type: text/bzr-bundle; charset="us-ascii";
	name="bzr/anitha.gopi@stripped"
Content-Transfer-Encoding: 7bit
Content-Disposition: inline

# Bazaar merge directive format 2 (Bazaar 0.90)
# revision_id: anitha.gopi@stripped
# target_branch: file:///home/anitha/mysql/repo/mysql-trunk-mod/
# testament_sha1: a8d5cd1d40f1e2b0b40e683d381490edd475103f
# timestamp: 2011-05-27 10:25:13 +0530
# source_branch: file:///home/anitha/mysql/repo/mysql-5.5-mod/
# base_revision_id: anitha.gopi@stripped\
#   d9e9a3tngn3b9nbc
# 
# Begin bundle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--===============1763045711==--