From f8683bfb4439e6ac70bbe3de5d88d1cc275f6011 Mon Sep 17 00:00:00 2001
From: "igor@olga.mysql.com" <>
Date: Sun, 1 Jul 2007 15:33:28 -0700
Subject: [PATCH 01/14] Fixed bug #25798. This bug may manifest itself not only
 with the queries for which the index-merge access method is chosen. It also
 may display itself for queries with DISTINCT.

The bug was in how the Unique::get method used the merge_buffers
function. To compare elements in the the queue employed by
merge_buffers() it must use the buffpek_compare function rather
than the function for binary comparison.
---
 mysql-test/r/innodb_mysql.result | 51 ++++++++++++++++++++++++++++++
 mysql-test/t/innodb_mysql.test   | 54 ++++++++++++++++++++++++++++++++
 sql/filesort.cc                  | 18 ++++++++---
 sql/sql_sort.h                   |  9 ++++++
 sql/uniques.cc                   | 13 ++++----
 5 files changed, 134 insertions(+), 11 deletions(-)

diff --git a/mysql-test/r/innodb_mysql.result b/mysql-test/r/innodb_mysql.result
index 11c7c2aedc9..df1c2165c45 100644
--- a/mysql-test/r/innodb_mysql.result
+++ b/mysql-test/r/innodb_mysql.result
@@ -676,4 +676,55 @@ INSERT INTO t1 VALUES (1);
 switch to connection default
 SET AUTOCOMMIT=default;
 DROP TABLE t1,t2;
+CREATE TABLE t1 (
+id int NOT NULL auto_increment PRIMARY KEY,
+b int NOT NULL,
+c datetime NOT NULL,
+INDEX idx_b(b),
+INDEX idx_c(c)
+) ENGINE=InnoDB;
+CREATE TABLE t2 (
+b int NOT NULL auto_increment PRIMARY KEY,
+c datetime NOT NULL
+) ENGINE= MyISAM;
+INSERT INTO t2(c) VALUES ('2007-01-01');
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+UPDATE t2 SET c='2007-01-02';
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+UPDATE t2 SET c='2007-01-03';
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+set @@sort_buffer_size=8192;
+SELECT COUNT(*) FROM t1;
+COUNT(*)
+3072
+EXPLAIN 
+SELECT COUNT(*) FROM t1 
+WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	idx_b,idx_c	NULL	NULL	NULL	3263	Using where
+SELECT COUNT(*) FROM t1 
+WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+COUNT(*)
+3072
+EXPLAIN 
+SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c) 
+WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	index_merge	idx_b,idx_c	idx_c,idx_b	8,4	NULL	3262	Using sort_union(idx_c,idx_b); Using where
+SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c)
+WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+COUNT(*)
+3072
+set @@sort_buffer_size=default;
+DROP TABLE t1,t2;
 End of 5.0 tests
diff --git a/mysql-test/t/innodb_mysql.test b/mysql-test/t/innodb_mysql.test
index 25ba9a258ff..eb995a748a5 100644
--- a/mysql-test/t/innodb_mysql.test
+++ b/mysql-test/t/innodb_mysql.test
@@ -670,5 +670,59 @@ DISCONNECT c1;
 DISCONNECT c2;
 DROP TABLE t1,t2;
 
+#
+# Bug #25798: a query with forced index merge returns wrong result 
+#
+
+CREATE TABLE t1 (
+  id int NOT NULL auto_increment PRIMARY KEY,
+  b int NOT NULL,
+  c datetime NOT NULL,
+  INDEX idx_b(b),
+  INDEX idx_c(c)
+) ENGINE=InnoDB;
+
+CREATE TABLE t2 (
+  b int NOT NULL auto_increment PRIMARY KEY,
+  c datetime NOT NULL
+) ENGINE= MyISAM;
+
+INSERT INTO t2(c) VALUES ('2007-01-01');
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+INSERT INTO t2(c) SELECT c FROM t2;
+
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+UPDATE t2 SET c='2007-01-02';
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+UPDATE t2 SET c='2007-01-03';
+INSERT INTO t1(b,c) SELECT b,c FROM t2;
+
+set @@sort_buffer_size=8192;
+
+SELECT COUNT(*) FROM t1;
+
+EXPLAIN 
+SELECT COUNT(*) FROM t1 
+  WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+SELECT COUNT(*) FROM t1 
+  WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+
+EXPLAIN 
+SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c) 
+  WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c)
+  WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
+
+set @@sort_buffer_size=default;
+
+DROP TABLE t1,t2;
 
 --echo End of 5.0 tests
diff --git a/sql/filesort.cc b/sql/filesort.cc
index d518ddbb117..f8868ed6927 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -1052,6 +1052,7 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
   BUFFPEK *buffpek;
   QUEUE queue;
   qsort2_cmp cmp;
+  void *first_cmp_arg;
   volatile THD::killed_state *killed= &current_thd->killed;
   THD::killed_state not_killable;
   DBUG_ENTER("merge_buffers");
@@ -1077,9 +1078,18 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
   /* The following will fire if there is not enough space in sort_buffer */
   DBUG_ASSERT(maxcount!=0);
   
+  if (param->unique_buff)
+  {
+    cmp= param->compare;
+    first_cmp_arg= (void *) &param->cmp_context;
+  }
+  else
+  {
+    cmp= get_ptr_compare(sort_length);
+    first_cmp_arg= (void*) &sort_length;
+  }
   if (init_queue(&queue, (uint) (Tb-Fb)+1, offsetof(BUFFPEK,key), 0,
-                 (queue_compare) (cmp= get_ptr_compare(sort_length)),
-                 (void*) &sort_length))
+                 (queue_compare) cmp, first_cmp_arg))
     DBUG_RETURN(1);                                /* purecov: inspected */
   for (buffpek= Fb ; buffpek <= Tb ; buffpek++)
   {
@@ -1132,7 +1142,7 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
       buffpek= (BUFFPEK*) queue_top(&queue);
       if (cmp)                                        // Remove duplicates
       {
-        if (!(*cmp)(&sort_length, &(param->unique_buff),
+        if (!(*cmp)(first_cmp_arg, &(param->unique_buff),
                     (uchar**) &buffpek->key))
               goto skip_duplicate;
             memcpy(param->unique_buff, (uchar*) buffpek->key, rec_length);
@@ -1184,7 +1194,7 @@ int merge_buffers(SORTPARAM *param, IO_CACHE *from_file,
   */
   if (cmp)
   {
-    if (!(*cmp)(&sort_length, &(param->unique_buff), (uchar**) &buffpek->key))
+    if (!(*cmp)(first_cmp_arg, &(param->unique_buff), (uchar**) &buffpek->key))
     {
       buffpek->key+= rec_length;         // Remove duplicate
       --buffpek->mem_count;
diff --git a/sql/sql_sort.h b/sql/sql_sort.h
index da28ca07e2c..1e9322f7f5b 100644
--- a/sql/sql_sort.h
+++ b/sql/sql_sort.h
@@ -50,6 +50,12 @@ typedef struct st_buffpek {		/* Struktur om sorteringsbuffrarna */
   ulong max_keys;			/* Max keys in buffert */
 } BUFFPEK;
 
+struct BUFFPEK_COMPARE_CONTEXT
+{
+  qsort_cmp2 key_compare;
+  void *key_compare_arg;
+};
+
 typedef struct st_sort_param {
   uint rec_length;          /* Length of sorted records */
   uint sort_length;			/* Length of sorted columns */
@@ -65,6 +71,9 @@ typedef struct st_sort_param {
   uchar *unique_buff;
   bool not_killable;
   char* tmp_buffer;
+  /* The fields below are used only by Unique class */
+  qsort2_cmp compare;
+  BUFFPEK_COMPARE_CONTEXT cmp_context;
 } SORTPARAM;
 
 
diff --git a/sql/uniques.cc b/sql/uniques.cc
index 9eb827f62a3..7c197d2a2e9 100644
--- a/sql/uniques.cc
+++ b/sql/uniques.cc
@@ -361,17 +361,12 @@ Unique::reset()
 }
 
 /*
-  The comparison function, passed to queue_init() in merge_walk() must
+  The comparison function, passed to queue_init() in merge_walk() and in
+  merge_buffers() when the latter is called from Uniques::get() must
   use comparison function of Uniques::tree, but compare members of struct
   BUFFPEK.
 */
 
-struct BUFFPEK_COMPARE_CONTEXT
-{
-  qsort_cmp2 key_compare;
-  void *key_compare_arg;
-};
-
 C_MODE_START
 
 static int buffpek_compare(void *arg, byte *key_ptr1, byte *key_ptr2)
@@ -630,6 +625,10 @@ bool Unique::get(TABLE *table)
   sort_param.unique_buff= sort_buffer+(sort_param.keys*
 				       sort_param.sort_length);
 
+  sort_param.compare= (qsort2_cmp) buffpek_compare;
+  sort_param.cmp_context.key_compare= tree.compare;
+  sort_param.cmp_context.key_compare_arg= tree.custom_arg;
+
   /* Merge the buffers to one file, removing duplicates */
   if (merge_many_buff(&sort_param,sort_buffer,file_ptr,&maxbuffer,&file))
     goto err;

From de0cf5d22f413c818c567e406843a921fd2c7fb4 Mon Sep 17 00:00:00 2001
From: "sergefp@mysql.com" <>
Date: Mon, 2 Jul 2007 22:18:41 +0400
Subject: [PATCH 02/14] Fix testcase to be platform-independent

---
 mysql-test/r/innodb_mysql.result | 6 +++---
 mysql-test/t/innodb_mysql.test   | 4 +++-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/mysql-test/r/innodb_mysql.result b/mysql-test/r/innodb_mysql.result
index df1c2165c45..8ddd3d2f1e8 100644
--- a/mysql-test/r/innodb_mysql.result
+++ b/mysql-test/r/innodb_mysql.result
@@ -1,4 +1,4 @@
-drop table if exists t1,t2;
+drop table if exists t1,t2,t3,t4;
 create table t1 (
 c_id int(11) not null default '0',
 org_id int(11) default null,
@@ -711,7 +711,7 @@ EXPLAIN
 SELECT COUNT(*) FROM t1 
 WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ALL	idx_b,idx_c	NULL	NULL	NULL	3263	Using where
+1	SIMPLE	t1	ALL	idx_b,idx_c	NULL	NULL	NULL	#	Using where
 SELECT COUNT(*) FROM t1 
 WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 COUNT(*)
@@ -720,7 +720,7 @@ EXPLAIN
 SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c) 
 WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	index_merge	idx_b,idx_c	idx_c,idx_b	8,4	NULL	3262	Using sort_union(idx_c,idx_b); Using where
+1	SIMPLE	t1	index_merge	idx_b,idx_c	idx_c,idx_b	8,4	NULL	#	Using sort_union(idx_c,idx_b); Using where
 SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c)
 WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 COUNT(*)
diff --git a/mysql-test/t/innodb_mysql.test b/mysql-test/t/innodb_mysql.test
index eb995a748a5..148181ee443 100644
--- a/mysql-test/t/innodb_mysql.test
+++ b/mysql-test/t/innodb_mysql.test
@@ -1,7 +1,7 @@
 -- source include/have_innodb.inc
 
 --disable_warnings
-drop table if exists t1,t2;
+drop table if exists t1,t2,t3,t4;
 --enable_warnings
 
 # BUG#16798: Uninitialized row buffer reads in ref-or-null optimizer
@@ -709,12 +709,14 @@ set @@sort_buffer_size=8192;
 
 SELECT COUNT(*) FROM t1;
 
+--replace_column 9 #
 EXPLAIN 
 SELECT COUNT(*) FROM t1 
   WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 SELECT COUNT(*) FROM t1 
   WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;
 
+--replace_column 9 #
 EXPLAIN 
 SELECT COUNT(*) FROM t1 FORCE INDEX(idx_b, idx_c) 
   WHERE (c >= '2007-01-02' AND c <= '2007-01-03') OR b >= 1;

From bad7900a5a2138adf1d82ca32d884fd075fd76a1 Mon Sep 17 00:00:00 2001
From: "gkodinov/kgeorge@magare.gmz" <>
Date: Tue, 3 Jul 2007 10:36:37 +0300
Subject: [PATCH 03/14] Bug #28983: 'reset master' in multiple threads and
 innodb tables asserts debug binary

We can't reliably check if the binary log is opened without
acquiring its mutex.
Fixed by removing this check.
---
 sql/log.cc | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/sql/log.cc b/sql/log.cc
index 818828f9557..dd989ebd76d 100644
--- a/sql/log.cc
+++ b/sql/log.cc
@@ -85,7 +85,7 @@ bool binlog_init()
 static int binlog_close_connection(THD *thd)
 {
   IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot];
-  DBUG_ASSERT(mysql_bin_log.is_open() && !my_b_tell(trans_log));
+  DBUG_ASSERT(!my_b_tell(trans_log));
   close_cached_file(trans_log);
   my_free((gptr)trans_log, MYF(0));
   return 0;
@@ -126,7 +126,7 @@ static int binlog_commit(THD *thd, bool all)
 {
   IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot];
   DBUG_ENTER("binlog_commit");
-  DBUG_ASSERT(mysql_bin_log.is_open() &&
+  DBUG_ASSERT(
      (all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN))));
 
   if (my_b_tell(trans_log) == 0)
@@ -155,7 +155,7 @@ static int binlog_rollback(THD *thd, bool all)
     unnecessary, doing extra work. The cause should be found and eliminated
   */
   DBUG_ASSERT(all || !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN)));
-  DBUG_ASSERT(mysql_bin_log.is_open() && my_b_tell(trans_log));
+  DBUG_ASSERT(my_b_tell(trans_log));
   /*
     Update the binary log with a BEGIN/ROLLBACK block if we have
     cached some queries and we updated some non-transactional
@@ -198,7 +198,7 @@ static int binlog_savepoint_set(THD *thd, void *sv)
 {
   IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot];
   DBUG_ENTER("binlog_savepoint_set");
-  DBUG_ASSERT(mysql_bin_log.is_open() && my_b_tell(trans_log));
+  DBUG_ASSERT(my_b_tell(trans_log));
 
   *(my_off_t *)sv= my_b_tell(trans_log);
   /* Write it to the binary log */
@@ -210,7 +210,7 @@ static int binlog_savepoint_rollback(THD *thd, void *sv)
 {
   IO_CACHE *trans_log= (IO_CACHE*)thd->ha_data[binlog_hton.slot];
   DBUG_ENTER("binlog_savepoint_rollback");
-  DBUG_ASSERT(mysql_bin_log.is_open() && my_b_tell(trans_log));
+  DBUG_ASSERT(my_b_tell(trans_log));
 
   /*
     Write ROLLBACK TO SAVEPOINT to the binlog cache if we have updated some

From dbe4fb94cad60318d54db399206848310e1fc9d3 Mon Sep 17 00:00:00 2001
From: "gshchepa/uchum@gleb.loc" <>
Date: Tue, 3 Jul 2007 19:37:46 +0500
Subject: [PATCH 04/14] Fixed bug #29294. The `SELECT 'r' INTO OUTFILE ...
 FIELDS ENCLOSED BY 'r' ' statement encoded the 'r' string to a 4 byte string
 of value x'725c7272' (sequence of 4 characters: r\rr). The LOAD DATA
 statement decoded this string to a 1 byte string of value x'0d' (ASCII
 Carriage Return character) instead of the original 'r' character. The same
 error also happened with the FIELDS ENCLOSED BY clause followed by special
 characters: 'n', 't', 'r', 'b', '0', 'Z' and 'N'.

NOTE 1: This is a result of the undocumented feature: the LOAD DATA INFILE
recognises 2-byte input sequences like \n, \t, \r and \Z in addition
to documented 2-byte sequences: \0 and \N. This feature should be
documented (here backspace character is a default ESCAPED BY character,
in the real-life example it may be any ESCAPED BY character).

NOTE 2, changed behaviour:
Now the `SELECT INTO OUTFILE' statement with the `FIELDS ENCLOSED BY'
clause followed by one of: 'n', 't', 'r', 'b', '0', 'Z' or 'N' characters
encodes this special character itself by doubling it ('r' --> 'rr'),
not by prepending it with an escape character.
---
 mysql-test/r/loaddata.result | 65 +++++++++++++++++++++++++++++++++++-
 mysql-test/t/loaddata.test   | 38 ++++++++++++++++++++-
 sql/sql_class.cc             |  5 ++-
 sql/sql_class.h              |  9 +++++
 sql/sql_load.cc              |  1 +
 5 files changed, 115 insertions(+), 3 deletions(-)

diff --git a/mysql-test/r/loaddata.result b/mysql-test/r/loaddata.result
index e1076cd3072..0906b1708c7 100644
--- a/mysql-test/r/loaddata.result
+++ b/mysql-test/r/loaddata.result
@@ -1,4 +1,4 @@
-drop table if exists t1;
+drop table if exists t1,t2;
 create table t1 (a date, b date, c date not null, d date);
 load data infile '../../std_data/loaddata1.dat' into table t1 fields terminated by ',';
 Warnings:
@@ -85,3 +85,66 @@ field1	field2
 a"b	cd"ef
 a"b	c"d"e
 drop table t1;
+CREATE TABLE t1 (
+id INT AUTO_INCREMENT PRIMARY KEY,
+c1 VARCHAR(255)
+);
+CREATE TABLE t2 (
+id INT,
+c2 VARCHAR(255)
+);
+INSERT INTO t1 (c1) VALUES
+('r'),   ('rr'),   ('rrr'),   ('rrrr'),
+('.r'),  ('.rr'),  ('.rrr'),  ('.rrrr'),
+('r.'),  ('rr.'),  ('rrr.'),  ('rrrr.'),
+('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.'),
+('\r'),  ('\\rr'), ('\\\rr'), ('\\\\rr');
+SELECT * FROM t1;
+id	c1
+1	r
+2	rr
+3	rrr
+4	rrrr
+5	.r
+6	.rr
+7	.rrr
+8	.rrrr
+9	r.
+10	rr.
+11	rrr.
+12	rrrr.
+13	.r.
+14	.rr.
+15	.rrr.
+16	.rrrr.
+17	
+18	\rr
+19	\
r
+20	\\rr
+SELECT * INTO OUTFILE 'MYSQL_TEST_DIR/var/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
+r1r	rrrr
+r2r	rrrrrr
+r3r	rrrrrrrr
+r4r	rrrrrrrrrr
+r5r	r.rrr
+r6r	r.rrrrr
+r7r	r.rrrrrrr
+r8r	r.rrrrrrrrr
+r9r	rrr.r
+r10r	rrrrr.r
+r11r	rrrrrrr.r
+r12r	rrrrrrrrr.r
+r13r	r.rr.r
+r14r	r.rrrr.r
+r15r	r.rrrrrr.r
+r16r	r.rrrrrrrr.r
+r17r	r
r
+r18r	r\\rrrrr
+r19r	r\\
rrr
+r20r	r\\\\rrrrr
+LOAD DATA INFILE 'MYSQL_TEST_DIR/var/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
+SELECT t1.id, c1, c2 FROM t1 LEFT  JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
+id	c1	c2
+SELECT t1.id, c1, c2 FROM t1 RIGHT JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
+id	c1	c2
+DROP TABLE t1,t2;
diff --git a/mysql-test/t/loaddata.test b/mysql-test/t/loaddata.test
index e989cb0b2ac..74d71985854 100644
--- a/mysql-test/t/loaddata.test
+++ b/mysql-test/t/loaddata.test
@@ -3,7 +3,7 @@
 #
 
 --disable_warnings
-drop table if exists t1;
+drop table if exists t1,t2;
 --enable_warnings
 
 create table t1 (a date, b date, c date not null, d date);
@@ -67,4 +67,40 @@ load data infile '../../std_data/loaddata5.dat' into table t1 fields terminated
 select * from t1;
 drop table t1;
 
+#
+# Bug #29294 SELECT INTO OUTFILE/LOAD DATA INFILE with special
+# characters in the FIELDS ENCLOSED BY clause
+#
+
+CREATE TABLE t1 (
+  id INT AUTO_INCREMENT PRIMARY KEY,
+  c1 VARCHAR(255)
+);
+
+CREATE TABLE t2 (
+  id INT,
+  c2 VARCHAR(255)
+);
+
+INSERT INTO t1 (c1) VALUES
+  ('r'),   ('rr'),   ('rrr'),   ('rrrr'),
+  ('.r'),  ('.rr'),  ('.rrr'),  ('.rrrr'),
+  ('r.'),  ('rr.'),  ('rrr.'),  ('rrrr.'),
+  ('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.'),
+  ('\r'),  ('\\rr'), ('\\\rr'), ('\\\\rr');
+SELECT * FROM t1;
+
+--exec rm -f $MYSQL_TEST_DIR/var/tmp/t1
+--replace_result $MYSQL_TEST_DIR MYSQL_TEST_DIR
+eval SELECT * INTO OUTFILE '$MYSQL_TEST_DIR/var/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
+--exec cat $MYSQL_TEST_DIR/var/tmp/t1
+
+--replace_result $MYSQL_TEST_DIR MYSQL_TEST_DIR
+eval LOAD DATA INFILE '$MYSQL_TEST_DIR/var/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
+SELECT t1.id, c1, c2 FROM t1 LEFT  JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
+SELECT t1.id, c1, c2 FROM t1 RIGHT JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
+
+--exec rm $MYSQL_TEST_DIR/var/tmp/t1
+DROP TABLE t1,t2;
+
 # End of 4.1 tests
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index b187d29021a..0f58f96cf57 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1020,6 +1020,7 @@ select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
   field_sep_char= (exchange->enclosed->length() ? (*exchange->enclosed)[0] :
 		   field_term_length ? (*exchange->field_term)[0] : INT_MAX);
   escape_char=	(exchange->escaped->length() ? (*exchange->escaped)[0] : -1);
+  is_ambiguous_field_sep= strchr(ESCAPE_CHARS, field_sep_char);
   line_sep_char= (exchange->line_term->length() ?
 		  (*exchange->line_term)[0] : INT_MAX);
   if (!field_term_length)
@@ -1113,7 +1114,9 @@ bool select_export::send_data(List<Item> &items)
 	      (int) *pos == line_sep_char || !*pos)
 	  {
 	    char tmp_buff[2];
-	    tmp_buff[0]= escape_char;
+            tmp_buff[0]= ((int) *pos == field_sep_char &&
+                          is_ambiguous_field_sep) ?
+                          field_sep_char : escape_char;
 	    tmp_buff[1]= *pos ? *pos : '0';
 	    if (my_b_write(&cache,(byte*) start,(uint) (pos-start)) ||
 		my_b_write(&cache,(byte*) tmp_buff,2))
diff --git a/sql/sql_class.h b/sql/sql_class.h
index db6f65cab55..eb2c8637651 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1224,9 +1224,18 @@ public:
 };
 
 
+#define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
+
+
 class select_export :public select_to_file {
   uint field_term_length;
   int field_sep_char,escape_char,line_sep_char;
+  /*
+    The is_ambiguous_field_sep field is true if a value of the field_sep_char
+    field is one of the 'n', 't', 'r' etc characters
+    (see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
+  */
+  bool is_ambiguous_field_sep;
   bool fixed_row_size;
 public:
   select_export(sql_exchange *ex) :select_to_file(ex) {}
diff --git a/sql/sql_load.cc b/sql/sql_load.cc
index 10124e5f5ff..bac981651c3 100644
--- a/sql/sql_load.cc
+++ b/sql/sql_load.cc
@@ -611,6 +611,7 @@ read_sep_field(THD *thd,COPY_INFO &info,TABLE *table,
 char
 READ_INFO::unescape(char chr)
 {
+  /* keep this switch synchornous with the ESCAPE_CHARS macro */
   switch(chr) {
   case 'n': return '\n';
   case 't': return '\t';

From 5f5929846b0f655282f243f9acf641aae310cf2b Mon Sep 17 00:00:00 2001
From: "gshchepa/uchum@gleb.loc" <>
Date: Tue, 3 Jul 2007 21:05:17 +0500
Subject: [PATCH 05/14] sql_class.cc:   Windows compilation error fix.

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

diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 0f58f96cf57..3e918a6a07c 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1020,7 +1020,7 @@ select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
   field_sep_char= (exchange->enclosed->length() ? (*exchange->enclosed)[0] :
 		   field_term_length ? (*exchange->field_term)[0] : INT_MAX);
   escape_char=	(exchange->escaped->length() ? (*exchange->escaped)[0] : -1);
-  is_ambiguous_field_sep= strchr(ESCAPE_CHARS, field_sep_char);
+  is_ambiguous_field_sep= test(strchr(ESCAPE_CHARS, field_sep_char));
   line_sep_char= (exchange->line_term->length() ?
 		  (*exchange->line_term)[0] : INT_MAX);
   if (!field_term_length)

From 1f85dac21c9533a17d2e9dfc9d4975785da3d175 Mon Sep 17 00:00:00 2001
From: "gshchepa/uchum@gleb.loc" <>
Date: Tue, 3 Jul 2007 21:45:20 +0500
Subject: [PATCH 06/14] loaddata.result, loaddata.test:   Test case update for
 bug #29294.

---
 mysql-test/r/loaddata.result | 11 +----------
 mysql-test/t/loaddata.test   |  3 +--
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/mysql-test/r/loaddata.result b/mysql-test/r/loaddata.result
index 0906b1708c7..83a0788b793 100644
--- a/mysql-test/r/loaddata.result
+++ b/mysql-test/r/loaddata.result
@@ -97,8 +97,7 @@ INSERT INTO t1 (c1) VALUES
 ('r'),   ('rr'),   ('rrr'),   ('rrrr'),
 ('.r'),  ('.rr'),  ('.rrr'),  ('.rrrr'),
 ('r.'),  ('rr.'),  ('rrr.'),  ('rrrr.'),
-('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.'),
-('\r'),  ('\\rr'), ('\\\rr'), ('\\\\rr');
+('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.');
 SELECT * FROM t1;
 id	c1
 1	r
@@ -117,10 +116,6 @@ id	c1
 14	.rr.
 15	.rrr.
 16	.rrrr.
-17	
-18	\rr
-19	\
r
-20	\\rr
 SELECT * INTO OUTFILE 'MYSQL_TEST_DIR/var/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
 r1r	rrrr
 r2r	rrrrrr
@@ -138,10 +133,6 @@ r13r	r.rr.r
 r14r	r.rrrr.r
 r15r	r.rrrrrr.r
 r16r	r.rrrrrrrr.r
-r17r	r
r
-r18r	r\\rrrrr
-r19r	r\\
rrr
-r20r	r\\\\rrrrr
 LOAD DATA INFILE 'MYSQL_TEST_DIR/var/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
 SELECT t1.id, c1, c2 FROM t1 LEFT  JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
 id	c1	c2
diff --git a/mysql-test/t/loaddata.test b/mysql-test/t/loaddata.test
index 74d71985854..14f33c6b396 100644
--- a/mysql-test/t/loaddata.test
+++ b/mysql-test/t/loaddata.test
@@ -86,8 +86,7 @@ INSERT INTO t1 (c1) VALUES
   ('r'),   ('rr'),   ('rrr'),   ('rrrr'),
   ('.r'),  ('.rr'),  ('.rrr'),  ('.rrrr'),
   ('r.'),  ('rr.'),  ('rrr.'),  ('rrrr.'),
-  ('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.'),
-  ('\r'),  ('\\rr'), ('\\\rr'), ('\\\\rr');
+  ('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.');
 SELECT * FROM t1;
 
 --exec rm -f $MYSQL_TEST_DIR/var/tmp/t1

From 79622efe7c6f84f0347456f5c05326239e042c48 Mon Sep 17 00:00:00 2001
From: "gshchepa/uchum@gleb.loc" <>
Date: Wed, 4 Jul 2007 03:15:37 +0500
Subject: [PATCH 07/14] loaddata.result, loaddata.test:   Updated test case for
 bug #29294.

---
 mysql-test/r/loaddata.result |  4 ++--
 mysql-test/t/loaddata.test   | 14 +++++++-------
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/mysql-test/r/loaddata.result b/mysql-test/r/loaddata.result
index 0aa95983264..031aa5c700c 100644
--- a/mysql-test/r/loaddata.result
+++ b/mysql-test/r/loaddata.result
@@ -117,7 +117,7 @@ id	c1
 14	.rr.
 15	.rrr.
 16	.rrrr.
-SELECT * INTO OUTFILE 'MYSQL_TEST_DIR/var/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
+SELECT * INTO OUTFILE 'MYSQLTEST_VARDIR/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
 r1r	rrrr
 r2r	rrrrrr
 r3r	rrrrrrrr
@@ -134,7 +134,7 @@ r13r	r.rr.r
 r14r	r.rrrr.r
 r15r	r.rrrrrr.r
 r16r	r.rrrrrrrr.r
-LOAD DATA INFILE 'MYSQL_TEST_DIR/var/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
+LOAD DATA INFILE 'MYSQLTEST_VARDIR/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
 SELECT t1.id, c1, c2 FROM t1 LEFT  JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
 id	c1	c2
 SELECT t1.id, c1, c2 FROM t1 RIGHT JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
diff --git a/mysql-test/t/loaddata.test b/mysql-test/t/loaddata.test
index c7f16fc303b..cdd3bb80b6e 100644
--- a/mysql-test/t/loaddata.test
+++ b/mysql-test/t/loaddata.test
@@ -89,17 +89,17 @@ INSERT INTO t1 (c1) VALUES
   ('.r.'), ('.rr.'), ('.rrr.'), ('.rrrr.');
 SELECT * FROM t1;
 
---exec rm -f $MYSQL_TEST_DIR/var/tmp/t1
---replace_result $MYSQL_TEST_DIR MYSQL_TEST_DIR
-eval SELECT * INTO OUTFILE '$MYSQL_TEST_DIR/var/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
---exec cat $MYSQL_TEST_DIR/var/tmp/t1
+--exec rm -f $MYSQLTEST_VARDIR/tmp/t1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+eval SELECT * INTO OUTFILE '$MYSQLTEST_VARDIR/tmp/t1' FIELDS ENCLOSED BY 'r' FROM t1;
+--exec cat $MYSQLTEST_VARDIR/tmp/t1
 
---replace_result $MYSQL_TEST_DIR MYSQL_TEST_DIR
-eval LOAD DATA INFILE '$MYSQL_TEST_DIR/var/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+eval LOAD DATA INFILE '$MYSQLTEST_VARDIR/tmp/t1' INTO TABLE t2 FIELDS ENCLOSED BY 'r';
 SELECT t1.id, c1, c2 FROM t1 LEFT  JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
 SELECT t1.id, c1, c2 FROM t1 RIGHT JOIN t2 ON t1.id=t2.id WHERE c1 != c2;
 
---exec rm $MYSQL_TEST_DIR/var/tmp/t1
+--exec rm $MYSQLTEST_VARDIR/tmp/t1
 DROP TABLE t1,t2;
 
 # End of 4.1 tests

From cdea05a79377865e0c89aaf72cdc24362b76887e Mon Sep 17 00:00:00 2001
From: "sergefp@mysql.com" <>
Date: Wed, 4 Jul 2007 17:11:56 +0400
Subject: [PATCH 08/14] Backport from 5.2: Fix valgrind failure: Don't access
 item_func->arguments() if item_func->argument_count()==0

---
 sql/sql_show.cc | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index 902b298e423..dc1a7bc3bd3 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1909,11 +1909,9 @@ bool uses_only_table_name_fields(Item *item, TABLE_LIST *table)
   if (item->type() == Item::FUNC_ITEM)
   {
     Item_func *item_func= (Item_func*)item;
-    Item **child;
-    Item **item_end= (item_func->arguments()) + item_func->argument_count();
-    for (child= item_func->arguments(); child != item_end; child++)
+    for (uint i=0; i<item_func->argument_count(); i++)
     {
-      if (!uses_only_table_name_fields(*child, table))
+      if (!uses_only_table_name_fields(item_func->arguments()[i], table))
         return 0;
     }
   }

From 4c02004da9ca0037731338c0fdd3fae8853de459 Mon Sep 17 00:00:00 2001
From: "igor@olga.mysql.com" <>
Date: Wed, 4 Jul 2007 21:12:07 -0700
Subject: [PATCH 09/14] Fixed bug #29392. This bug may manifest itself for
 select queries over a multi-table view that includes an ORDER BY clause in
 its definition. If the select list of the query contains references to the
 same view column with different aliases the names of the columns in the
 result output will be nevertheless the same, coinciding with one of the
 alias.

The bug happened because the method Item_ref::get_tmp_table_item that
was inherited by the class Item_direct_view_ref ignored the fact that
the name of the view column reference must be inherited by the fields
of the temporary table that was created in order to get the result rows
sorted.
---
 mysql-test/r/view.result | 47 ++++++++++++++++++++++++++++++++++
 mysql-test/t/view.test   | 55 ++++++++++++++++++++++++++++++++++++++++
 sql/item.h               |  6 +++++
 3 files changed, 108 insertions(+)

diff --git a/mysql-test/r/view.result b/mysql-test/r/view.result
index 9adb3f96142..c51a4c30960 100644
--- a/mysql-test/r/view.result
+++ b/mysql-test/r/view.result
@@ -3500,4 +3500,51 @@ id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
 1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	4	Using where
 DROP VIEW v1;
 DROP TABLE t1;
+CREATE TABLE t1 (
+person_id int NOT NULL PRIMARY KEY,
+username varchar(40) default NULL,
+status_flg char(1) NOT NULL default 'A'
+);
+CREATE TABLE t2 (
+person_role_id int NOT NULL auto_increment PRIMARY KEY,
+role_id int NOT NULL,
+person_id int NOT NULL,
+INDEX idx_person_id (person_id),
+INDEX idx_role_id (role_id)
+);
+CREATE TABLE t3 (
+role_id int NOT NULL auto_increment PRIMARY KEY,
+role_name varchar(100) default NULL,
+app_name varchar(40) NOT NULL,
+INDEX idx_app_name(app_name)
+);
+CREATE VIEW v1 AS 
+SELECT profile.person_id AS person_id
+FROM t1 profile, t2 userrole, t3 role
+WHERE userrole.person_id = profile.person_id AND
+role.role_id = userrole.role_id AND
+profile.status_flg = 'A'
+  ORDER BY profile.person_id,role.app_name,role.role_name;
+INSERT INTO  t1 VALUES
+(6,'Sw','A'), (-1136332546,'ols','e'), (0,'    *\n','0'),
+(-717462680,'ENTS Ta','0'), (-904346964,'ndard SQL\n','0');
+INSERT INTO t2 VALUES
+(1,3,6),(2,4,7),(3,5,8),(4,6,9),(5,1,6),(6,1,7),(7,1,8),(8,1,9),(9,1,10);
+INSERT INTO t3 VALUES 
+(1,'NUCANS_APP_USER','NUCANSAPP'),(2,'NUCANS_TRGAPP_USER','NUCANSAPP'),
+(3,'IA_INTAKE_COORDINATOR','IACANS'),(4,'IA_SCREENER','IACANS'),
+(5,'IA_SUPERVISOR','IACANS'),(6,'IA_READONLY','IACANS'),
+(7,'SOC_USER','SOCCANS'),(8,'CAYIT_USER','CAYITCANS'),
+(9,'RTOS_DCFSPOS_SUPERVISOR','RTOS');
+EXPLAIN SELECT t.person_id AS a, t.person_id AS b FROM v1 t WHERE t.person_id=6;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	profile	const	PRIMARY	PRIMARY	4	const	1	Using temporary; Using filesort
+1	SIMPLE	userrole	ref	idx_person_id,idx_role_id	idx_person_id	4	const	2	
+1	SIMPLE	role	eq_ref	PRIMARY	PRIMARY	4	test.userrole.role_id	1	
+SELECT t.person_id AS a, t.person_id AS b FROM v1 t WHERE t.person_id=6;
+a	b
+6	6
+6	6
+DROP VIEW v1;
+DROP TABLE t1,t2,t3;
 End of 5.0 tests.
diff --git a/mysql-test/t/view.test b/mysql-test/t/view.test
index f670ac8a49d..c7f722a18a5 100644
--- a/mysql-test/t/view.test
+++ b/mysql-test/t/view.test
@@ -3348,4 +3348,59 @@ EXPLAIN SELECT a, SUM(b) FROM v1 WHERE a=1 GROUP BY a;
 DROP VIEW v1;
 DROP TABLE t1;
 
+#
+# Bug #29392: SELECT over a multi-table view with ORDER BY  
+#             selecting the same view column with two different aliases  
+#
+
+CREATE TABLE t1 (
+  person_id int NOT NULL PRIMARY KEY,
+  username varchar(40) default NULL,
+  status_flg char(1) NOT NULL default 'A'
+);
+
+CREATE TABLE t2 (
+  person_role_id int NOT NULL auto_increment PRIMARY KEY,
+  role_id int NOT NULL,
+  person_id int NOT NULL,
+  INDEX idx_person_id (person_id),
+  INDEX idx_role_id (role_id)
+);
+
+CREATE TABLE t3 (
+  role_id int NOT NULL auto_increment PRIMARY KEY,
+  role_name varchar(100) default NULL,
+  app_name varchar(40) NOT NULL,
+  INDEX idx_app_name(app_name)
+);
+
+CREATE VIEW v1 AS 
+SELECT profile.person_id AS person_id
+  FROM t1 profile, t2 userrole, t3 role
+    WHERE userrole.person_id = profile.person_id AND
+          role.role_id = userrole.role_id AND
+          profile.status_flg = 'A'
+  ORDER BY profile.person_id,role.app_name,role.role_name;
+
+INSERT INTO  t1 VALUES
+ (6,'Sw','A'), (-1136332546,'ols','e'), (0,'    *\n','0'),
+ (-717462680,'ENTS Ta','0'), (-904346964,'ndard SQL\n','0');
+
+INSERT INTO t2 VALUES
+  (1,3,6),(2,4,7),(3,5,8),(4,6,9),(5,1,6),(6,1,7),(7,1,8),(8,1,9),(9,1,10);
+
+INSERT INTO t3 VALUES 
+  (1,'NUCANS_APP_USER','NUCANSAPP'),(2,'NUCANS_TRGAPP_USER','NUCANSAPP'),
+  (3,'IA_INTAKE_COORDINATOR','IACANS'),(4,'IA_SCREENER','IACANS'),
+  (5,'IA_SUPERVISOR','IACANS'),(6,'IA_READONLY','IACANS'),
+  (7,'SOC_USER','SOCCANS'),(8,'CAYIT_USER','CAYITCANS'),
+  (9,'RTOS_DCFSPOS_SUPERVISOR','RTOS');
+ 
+EXPLAIN SELECT t.person_id AS a, t.person_id AS b FROM v1 t WHERE t.person_id=6;
+SELECT t.person_id AS a, t.person_id AS b FROM v1 t WHERE t.person_id=6;
+
+DROP VIEW v1;
+DROP TABLE t1,t2,t3;
+
 --echo End of 5.0 tests.
+
diff --git a/sql/item.h b/sql/item.h
index 3478095351a..a880f86f601 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1983,6 +1983,12 @@ public:
 
   bool fix_fields(THD *, Item **);
   bool eq(const Item *item, bool binary_cmp) const;
+  Item *get_tmp_table_item(THD *thd)
+  {
+    Item *item= Item_ref::get_tmp_table_item(thd);
+    item->name= name;
+    return item;
+  }
   virtual Ref_Type ref_type() { return VIEW_REF; }
 };
 

From 1532452a00e49a71880707f4ae279d19aab14724 Mon Sep 17 00:00:00 2001
From: "gkodinov/kgeorge@magare.gmz" <>
Date: Thu, 5 Jul 2007 18:24:48 +0300
Subject: [PATCH 10/14] Bug #29166: AsText() needs to know the maximum number
 of characters a IEEE double precision value can occupy to make sure there's
 enough buffer space. The number was too small to hold all possible values and
 this caused buffer overruns. Fixed by correcting the calculation of the
 maximum digits in a string representation of an IEEE double precision value
 as printed by String::qs_append(double).

---
 mysql-test/r/gis.result |  3 +++
 mysql-test/t/gis.test   | 20 ++++++++++++++++++++
 sql/spatial.cc          | 23 ++++++++++++++++++++++-
 3 files changed, 45 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/gis.result b/mysql-test/r/gis.result
index d1f292cda0c..edf017f24d4 100644
--- a/mysql-test/r/gis.result
+++ b/mysql-test/r/gis.result
@@ -885,4 +885,7 @@ AsText(a)
 POINT(1 1)
 LINESTRING(0 0,1 1,2 2)
 drop table t1, t2;
+SELECT 1;
+1
+1
 End of 5.0 tests
diff --git a/mysql-test/t/gis.test b/mysql-test/t/gis.test
index 95ccc6272e2..79743a0b8f4 100644
--- a/mysql-test/t/gis.test
+++ b/mysql-test/t/gis.test
@@ -570,4 +570,24 @@ create table t2 as select f2 as a from t1 union select f3 from t1;
 desc t2;
 select AsText(a) from t2; 
 drop table t1, t2;
+
+#
+# Bug #29166: MYsql crash when query is run
+#
+
+# The test query itself is not logged : too large output.
+# The real test is the second query : see if the first hasn't crashed the
+# server
+--disable_query_log
+--disable_result_log
+SELECT AsText(GeometryFromText(CONCAT(
+  'MULTIPOLYGON(((',
+  REPEAT ('-0.00000000001234567890123456789012 -0.123456789012345678,', 1000),
+  '-0.00000000001234567890123456789012 -0.123456789012345678',
+  ')))'
+))) AS a;
+--enable_result_log
+--enable_query_log
+SELECT 1;
+
 --echo End of 5.0 tests
diff --git a/sql/spatial.cc b/sql/spatial.cc
index 939e7d2a3b4..69d0c15748a 100644
--- a/sql/spatial.cc
+++ b/sql/spatial.cc
@@ -17,7 +17,28 @@
 
 #ifdef HAVE_SPATIAL
 
-#define MAX_DIGITS_IN_DOUBLE 16
+/* 
+  exponential notation :
+  1   sign
+  1   number before the decimal point
+  1   decimal point
+  14  number of significant digits (see String::qs_append(double))
+  1   'e' sign
+  1   exponent sign
+  3   exponent digits
+  ==
+  22
+
+  "f" notation :
+  1   optional 0
+  1   sign
+  14  number significant digits (see String::qs_append(double) )
+  1   decimal point
+  ==
+  17
+*/
+
+#define MAX_DIGITS_IN_DOUBLE 22
 
 /***************************** Gis_class_info *******************************/
 

From c33f4d3d85fdbedd21e9b9830341b7e3e3434151 Mon Sep 17 00:00:00 2001
From: "gshchepa/uchum@gleb.loc" <>
Date: Fri, 6 Jul 2007 03:43:23 +0500
Subject: [PATCH 11/14] Fixed bug #29442. The SELECT INTO OUTFILE FIELDS
 ENCLOSED BY digit or minus sign, followed by the same LOAD DATA INFILE
 statement, used wrond encoding of non-string fields contained the enclosed
 character in their text representation.

Example:
  SELECT 15, 9 INTO OUTFILE 'text' FIELDS ENCLOSED BY '5';

Old encoded result in the text file:
  5155 595
         ^ was decoded as the 1st enclosing character of the 2nd field;
        ^ was skipped as garbage;
  ^    ^ was decoded as a pair of englosing characters of the 1st field;
      ^   was decoded as traling space of the first field;
    ^^ was decoded as a doubled enclosed character.

New encoded result in the text file:
  51\55 595
  ^   ^ pair of enclosing characters of the 1st field;
    ^^ escaped enclosed character.
---
 mysql-test/r/loaddata.result | 14 ++++++++++++++
 mysql-test/t/loaddata.test   | 25 +++++++++++++++++++++++++
 sql/sql_class.cc             |  4 +++-
 sql/sql_class.h              | 12 ++++++++++++
 4 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/loaddata.result b/mysql-test/r/loaddata.result
index 031aa5c700c..7fff2700779 100644
--- a/mysql-test/r/loaddata.result
+++ b/mysql-test/r/loaddata.result
@@ -238,3 +238,17 @@ f1
 1
 2
 drop table t1,t2;
+CREATE TABLE t1 (c1 INT, c2 TIMESTAMP, c3 REAL, c4 DOUBLE);
+INSERT INTO t1 (c1, c2, c3, c4) VALUES (10, '1970-02-01 01:02:03', 1.1E-100, 1.1E+100);
+SELECT * FROM t1;
+c1	c2	c3	c4
+10	1970-02-01 01:02:03	1.1e-100	1.1e+100
+SELECT * INTO OUTFILE 'MYSQLTEST_VARDIR/tmp/t1' FIELDS ENCLOSED BY '-' FROM t1;
+-10-	-1970\-02\-01 01:02:03-	-1.1e\-100-	-1.1e+100-
+EOF
+TRUNCATE t1;
+LOAD DATA INFILE 'MYSQLTEST_VARDIR/tmp/t1' INTO TABLE t1 FIELDS ENCLOSED BY '-';
+SELECT * FROM t1;
+c1	c2	c3	c4
+10	1970-02-01 01:02:03	1.1e-100	1.1e+100
+DROP TABLE t1;
diff --git a/mysql-test/t/loaddata.test b/mysql-test/t/loaddata.test
index cdd3bb80b6e..260e760e7b3 100644
--- a/mysql-test/t/loaddata.test
+++ b/mysql-test/t/loaddata.test
@@ -213,4 +213,29 @@ select f1 from t1 where f2 <> '0000-00-00 00:00:00' order by f1;
 --exec rm $MYSQLTEST_VARDIR/tmp/t2
 drop table t1,t2;
 
+#
+# Bug#29442: SELECT INTO OUTFILE FIELDS ENCLOSED BY digit, minus sign etc
+#            corrupts non-string fields containing this character.
+#
+
+CREATE TABLE t1 (c1 INT, c2 TIMESTAMP, c3 REAL, c4 DOUBLE);
+
+INSERT INTO t1 (c1, c2, c3, c4) VALUES (10, '1970-02-01 01:02:03', 1.1E-100, 1.1E+100);
+SELECT * FROM t1;
+
+--exec rm -f $MYSQLTEST_VARDIR/tmp/t1
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+eval SELECT * INTO OUTFILE '$MYSQLTEST_VARDIR/tmp/t1' FIELDS ENCLOSED BY '-' FROM t1;
+--exec cat $MYSQLTEST_VARDIR/tmp/t1
+--exec echo EOF
+
+TRUNCATE t1;
+
+--replace_result $MYSQLTEST_VARDIR MYSQLTEST_VARDIR
+eval LOAD DATA INFILE '$MYSQLTEST_VARDIR/tmp/t1' INTO TABLE t1 FIELDS ENCLOSED BY '-';
+SELECT * FROM t1;
+
+--exec rm $MYSQLTEST_VARDIR/tmp/t1
+DROP TABLE t1;
+
 # End of 5.0 tests
diff --git a/sql/sql_class.cc b/sql/sql_class.cc
index 117c20352ce..036ba217a9b 100644
--- a/sql/sql_class.cc
+++ b/sql/sql_class.cc
@@ -1210,6 +1210,7 @@ select_export::prepare(List<Item> &list, SELECT_LEX_UNIT *u)
 		   field_term_length ? (*exchange->field_term)[0] : INT_MAX);
   escape_char=	(exchange->escaped->length() ? (*exchange->escaped)[0] : -1);
   is_ambiguous_field_sep= test(strchr(ESCAPE_CHARS, field_sep_char));
+  is_unsafe_field_sep= test(strchr(NUMERIC_CHARS, field_sep_char));
   line_sep_char= (exchange->line_term->length() ?
 		  (*exchange->line_term)[0] : INT_MAX);
   if (!field_term_length)
@@ -1284,7 +1285,8 @@ bool select_export::send_data(List<Item> &items)
 	used_length=min(res->length(),item->max_length);
       else
 	used_length=res->length();
-      if (result_type == STRING_RESULT && escape_char != -1)
+      if ((result_type == STRING_RESULT || is_unsafe_field_sep) &&
+           escape_char != -1)
       {
         char *pos, *start, *end;
         CHARSET_INFO *res_charset= res->charset();
diff --git a/sql/sql_class.h b/sql/sql_class.h
index 23c499aea07..a5cbc21684f 100644
--- a/sql/sql_class.h
+++ b/sql/sql_class.h
@@ -1929,6 +1929,12 @@ public:
 #define ESCAPE_CHARS "ntrb0ZN" // keep synchronous with READ_INFO::unescape
 
 
+/*
+ List of all possible characters of a numeric value text representation.
+*/
+#define NUMERIC_CHARS ".0123456789e+-"
+
+
 class select_export :public select_to_file {
   uint field_term_length;
   int field_sep_char,escape_char,line_sep_char;
@@ -1938,6 +1944,12 @@ class select_export :public select_to_file {
     (see the READ_INFO::unescape method and the ESCAPE_CHARS constant value).
   */
   bool is_ambiguous_field_sep;
+  /*
+    The is_unsafe_field_sep field is true if a value of the field_sep_char
+    field is one of the '0'..'9', '+', '-', '.' and 'e' characters
+    (see the NUMERIC_CHARS constant value).
+  */
+  bool is_unsafe_field_sep;
   bool fixed_row_size;
 public:
   select_export(sql_exchange *ex) :select_to_file(ex) {}

From db649ad5d1428051fe39cb42c782fb2ecea4d961 Mon Sep 17 00:00:00 2001
From: "knielsen@ymer.(none)" <>
Date: Sat, 7 Jul 2007 07:46:17 +0200
Subject: [PATCH 12/14] Bug #29543 GCov information not written in case of
 crash.

For GCov builds, if the server crashes, the normal exit handler for writing
coverage information is not executed due to the abnormal termination.

Fix this by explicitly calling the __gcov_flush function in our crash handler.
---
 BUILD/compile-pentium-gcov | 5 +++--
 sql/stacktrace.c           | 9 +++++++++
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/BUILD/compile-pentium-gcov b/BUILD/compile-pentium-gcov
index 26475824570..0d561d5b147 100755
--- a/BUILD/compile-pentium-gcov
+++ b/BUILD/compile-pentium-gcov
@@ -13,8 +13,9 @@ export LDFLAGS="-fprofile-arcs -ftest-coverage"
 
 # The  -fprofile-arcs and -ftest-coverage options cause GCC to instrument the
 # code with profiling information used by gcov.
-# the -DDISABLE_TAO_ASM is needed to avoid build failures in Yassl.
-extra_flags="$pentium_cflags -fprofile-arcs -ftest-coverage -DDISABLE_TAO_ASM $debug_cflags $max_cflags -DMYSQL_SERVER_SUFFIX=-gcov"
+# The -DDISABLE_TAO_ASM is needed to avoid build failures in Yassl.
+# The -DHAVE_gcov enables code to write out coverage info even when crashing.
+extra_flags="$pentium_cflags -fprofile-arcs -ftest-coverage -DDISABLE_TAO_ASM $debug_cflags $max_cflags -DMYSQL_SERVER_SUFFIX=-gcov -DHAVE_gcov"
 c_warnings="$c_warnings $debug_extra_warnings"
 cxx_warnings="$cxx_warnings $debug_extra_warnings"
 extra_configs="$pentium_configs $debug_configs --disable-shared $static_link"
diff --git a/sql/stacktrace.c b/sql/stacktrace.c
index d8e9b7fd883..c947beafac3 100644
--- a/sql/stacktrace.c
+++ b/sql/stacktrace.c
@@ -241,6 +241,15 @@ void write_core(int sig)
 void write_core(int sig)
 {
   signal(sig, SIG_DFL);
+#ifdef HAVE_gcov
+  /*
+    For GCOV build, crashing will prevent the writing of code coverage
+    information from this process, causing gcov output to be incomplete.
+    So we force the writing of coverage information here before terminating.
+  */
+  extern void __gcov_flush(void);
+  __gcov_flush();
+#endif
   pthread_kill(pthread_self(), sig);
 #if defined(P_MYID) && !defined(SCO)
   /* On Solaris, the above kill is not enough */

From 87c3d18f6fa0e143944192d380ec8225fb12b1b1 Mon Sep 17 00:00:00 2001
From: "igor@olga.mysql.com" <>
Date: Sat, 7 Jul 2007 10:33:02 -0700
Subject: [PATCH 13/14] Fixed bug #29415. The cast operation ignored the cases
 when the precision and/or the scale exceeded the limits, 65 and 30
 respectively. No errors were reported in these cases. For some queries this
 may lead to an assertion abort.

Fixed by throwing errors for such cases.
---
 mysql-test/r/type_newdecimal.result | 20 ++++++++++++++++++++
 mysql-test/t/type_newdecimal.test   | 23 +++++++++++++++++++++++
 sql/item_create.cc                  | 12 ++++++++++++
 3 files changed, 55 insertions(+)

diff --git a/mysql-test/r/type_newdecimal.result b/mysql-test/r/type_newdecimal.result
index 9e165721033..d858c3cbdd6 100644
--- a/mysql-test/r/type_newdecimal.result
+++ b/mysql-test/r/type_newdecimal.result
@@ -1471,4 +1471,24 @@ drop table t1;
 SELECT 1.000000000000 * 99.999999999998 / 100 a,1.000000000000 * (99.999999999998 / 100) b;
 a	b
 0.9999999999999800000000000000	0.9999999999999800000000000000
+SELECT CAST(1 AS decimal(65,10));
+CAST(1 AS decimal(65,10))
+1.0000000000
+SELECT CAST(1 AS decimal(66,10));
+ERROR 42000: Too big precision 66 specified for column '1'. Maximum is 65.
+SELECT CAST(1 AS decimal(65,30));
+CAST(1 AS decimal(65,30))
+1.000000000000000000000000000000
+SELECT CAST(1 AS decimal(65,31));
+ERROR 42000: Too big scale 31 specified for column '1'. Maximum is 30.
+CREATE TABLE t1 (a int DEFAULT NULL, b int DEFAULT NULL);
+INSERT INTO t1 VALUES (3,30), (1,10), (2,10);
+SELECT a+CAST(1 AS decimal(65,30)) AS aa, SUM(b) FROM t1 GROUP BY aa;
+aa	SUM(b)
+2.000000000000000000000000000000	10
+3.000000000000000000000000000000	10
+4.000000000000000000000000000000	30
+SELECT a+CAST(1 AS decimal(65,31)) AS aa, SUM(b) FROM t1 GROUP BY aa;
+ERROR 42000: Too big scale 31 specified for column '1'. Maximum is 30.
+DROP TABLE t1;
 End of 5.0 tests
diff --git a/mysql-test/t/type_newdecimal.test b/mysql-test/t/type_newdecimal.test
index d2b808bd5e0..73142eb41c0 100644
--- a/mysql-test/t/type_newdecimal.test
+++ b/mysql-test/t/type_newdecimal.test
@@ -1162,4 +1162,27 @@ drop table t1;
 #
 
 SELECT 1.000000000000 * 99.999999999998 / 100 a,1.000000000000 * (99.999999999998 / 100) b;
+
+#
+# Bug #29415: CAST AS DECIMAL(P,S) with too big precision/scale 
+#
+
+SELECT CAST(1 AS decimal(65,10));
+--error ER_TOO_BIG_PRECISION
+SELECT CAST(1 AS decimal(66,10));
+
+SELECT CAST(1 AS decimal(65,30));
+--error ER_TOO_BIG_SCALE
+SELECT CAST(1 AS decimal(65,31));
+
+CREATE TABLE t1 (a int DEFAULT NULL, b int DEFAULT NULL);
+INSERT INTO t1 VALUES (3,30), (1,10), (2,10);
+SELECT a+CAST(1 AS decimal(65,30)) AS aa, SUM(b) FROM t1 GROUP BY aa;
+--error ER_TOO_BIG_SCALE
+SELECT a+CAST(1 AS decimal(65,31)) AS aa, SUM(b) FROM t1 GROUP BY aa;
+
+DROP TABLE t1;
+
 --echo End of 5.0 tests
+
+
diff --git a/sql/item_create.cc b/sql/item_create.cc
index 42cbdc8c280..50db1c37371 100644
--- a/sql/item_create.cc
+++ b/sql/item_create.cc
@@ -471,6 +471,18 @@ Item *create_func_cast(Item *a, Cast_target cast_type,
       my_error(ER_M_BIGGER_THAN_D, MYF(0), "");
       return 0;
     }
+    if (len > DECIMAL_MAX_PRECISION)
+    {
+      my_error(ER_TOO_BIG_PRECISION, MYF(0), len, a->name,
+               DECIMAL_MAX_PRECISION);
+      return 0;
+    }
+    if (dec > DECIMAL_MAX_SCALE)
+    {
+      my_error(ER_TOO_BIG_SCALE, MYF(0), dec, a->name,
+               DECIMAL_MAX_SCALE);
+      return 0;
+    }
     res= new Item_decimal_typecast(a, len, dec);
     break;
   case ITEM_CAST_CHAR:

From 63d538575b7c1142e5467692fd70ed2042041294 Mon Sep 17 00:00:00 2001
From: "igor@olga.mysql.com" <>
Date: Sat, 7 Jul 2007 12:31:55 -0700
Subject: [PATCH 14/14] Fixed bug #29417. An assertion abort could occur for
 some grouping queries that employed decimal user variables with assignments
 to them.

The problem appeared the constructors of the class Field_new_decimal
because the function my_decimal_length_to_precision did not guarantee
returning decimal precision not greater than DECIMAL_MAX_PRECISION.
---
 mysql-test/r/type_newdecimal.result |  8 ++++++++
 mysql-test/t/type_newdecimal.test   | 13 +++++++++++++
 sql/field.cc                        |  2 ++
 3 files changed, 23 insertions(+)

diff --git a/mysql-test/r/type_newdecimal.result b/mysql-test/r/type_newdecimal.result
index 9e165721033..c580568f3d4 100644
--- a/mysql-test/r/type_newdecimal.result
+++ b/mysql-test/r/type_newdecimal.result
@@ -1471,4 +1471,12 @@ drop table t1;
 SELECT 1.000000000000 * 99.999999999998 / 100 a,1.000000000000 * (99.999999999998 / 100) b;
 a	b
 0.9999999999999800000000000000	0.9999999999999800000000000000
+CREATE TABLE t1 (a int DEFAULT NULL, b int DEFAULT NULL);
+INSERT INTO t1 VALUES (3,30), (1,10), (2,10);
+SET @a= CAST(1 AS decimal);
+SELECT 1 FROM t1 GROUP BY @b := @a, @b;
+1
+1
+1
+DROP TABLE t1;
 End of 5.0 tests
diff --git a/mysql-test/t/type_newdecimal.test b/mysql-test/t/type_newdecimal.test
index d2b808bd5e0..da321cc9932 100644
--- a/mysql-test/t/type_newdecimal.test
+++ b/mysql-test/t/type_newdecimal.test
@@ -1162,4 +1162,17 @@ drop table t1;
 #
 
 SELECT 1.000000000000 * 99.999999999998 / 100 a,1.000000000000 * (99.999999999998 / 100) b;
+
+#
+# Bug #29417: assertion abort for a grouping query with decimal user variable
+#
+
+CREATE TABLE t1 (a int DEFAULT NULL, b int DEFAULT NULL);
+INSERT INTO t1 VALUES (3,30), (1,10), (2,10);
+
+SET @a= CAST(1 AS decimal);
+SELECT 1 FROM t1 GROUP BY @b := @a, @b;
+
+DROP TABLE t1;
+
 --echo End of 5.0 tests
diff --git a/sql/field.cc b/sql/field.cc
index f81b1c33fa7..2e227f0e67e 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -2267,6 +2267,7 @@ Field_new_decimal::Field_new_decimal(char *ptr_arg,
              dec_arg, zero_arg, unsigned_arg)
 {
   precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
+  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
   DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
               (dec <= DECIMAL_MAX_SCALE));
   bin_size= my_decimal_get_binary_size(precision, dec);
@@ -2286,6 +2287,7 @@ Field_new_decimal::Field_new_decimal(uint32 len_arg,
              0, unsigned_arg)
 {
   precision= my_decimal_length_to_precision(len_arg, dec_arg, unsigned_arg);
+  set_if_smaller(precision, DECIMAL_MAX_PRECISION);
   DBUG_ASSERT((precision <= DECIMAL_MAX_PRECISION) &&
               (dec <= DECIMAL_MAX_SCALE));
   bin_size= my_decimal_get_binary_size(precision, dec);