From 1991a87d831bb48b31989c622e35acda11df7fef Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Fri, 26 May 2006 01:24:14 +0400
Subject: [PATCH 01/11] Fixed bug#16716: subselect in concat() may lead to a
 wrong result.

The Item_func_concat::val_str() function tries to make as less re-allocations
as possible. This results in appending strings returned by 2nd and next
arguments to the string returned by 1st argument if the buffer for the first
argument has enough free space. A constant subselect is evaluated only once
and its result is stored in an Item_cache_str. In the case when the first
argument of the concat() function is such a subselect Item_cache_str returns
the stored value and Item_func_concat::val_str() append values of other
arguments to it. But for the next row the value in the Item_cache_str isn't
restored because the subselect is a constant one and it isn't evaluated second
time. This results in appending string values of 2nd and next arguments to the
result of the previous Item_func_concat::val_str() call.

The Item_func_concat::val_str() function now checks whether the first argument
is a constant one and if so it doesn't append values of 2nd and next arguments
to the string value returned by it.


mysql-test/t/func_concat.test:
  Added test case for bug#16716: subselect in concat() may lead to a wrong result.
mysql-test/r/func_concat.result:
  Added test case for bug#16716: subselect in concat() may lead to a wrong result.
sql/item_strfunc.cc:
  Fixed bug#16716: subselect in concat() may lead to a wrong result.
  The Item_func_concat::val_str() function now checks whether the first argument
  is a constant one and if so it doesn't append values of 2nd and next arguments
  to the string value returned by it.
---
 mysql-test/r/func_concat.result | 7 +++++++
 mysql-test/t/func_concat.test   | 7 +++++++
 sql/item_strfunc.cc             | 5 ++++-
 3 files changed, 18 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/func_concat.result b/mysql-test/r/func_concat.result
index cf6fbf2da4f..94f1f640523 100644
--- a/mysql-test/r/func_concat.result
+++ b/mysql-test/r/func_concat.result
@@ -64,3 +64,10 @@ select 'a' union select concat('a', -0.0);
 a
 a
 good
+select concat((select x from (select 'a' as x) as t1 ),
+(select y from (select 'b' as y) as t2 )) from (select 1 union select 2 )
+as t3;
+concat((select x from (select 'a' as x) as t1 ),
+(select y from (select 'b' as y) as t2 ))
+ab
+ab
diff --git a/mysql-test/t/func_concat.test b/mysql-test/t/func_concat.test
index 69ce10c83c9..f546a25f647 100644
--- a/mysql-test/t/func_concat.test
+++ b/mysql-test/t/func_concat.test
@@ -50,4 +50,11 @@ select 'a' union select concat('a', -0);
 --replace_result 'a-0.0' good 'a0.0' good
 select 'a' union select concat('a', -0.0);
 
+#
+# Bug#16716: subselect in concat() may lead to a wrong result
+#
+select concat((select x from (select 'a' as x) as t1 ),
+  (select y from (select 'b' as y) as t2 )) from (select 1 union select 2 )
+  as t3;
+
 # End of 4.1 tests
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index e74d0100b55..0dfbf3b7a1d 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -252,11 +252,13 @@ String *Item_func_concat::val_str(String *str)
   DBUG_ASSERT(fixed == 1);
   String *res,*res2,*use_as_buff;
   uint i;
+  bool is_const= 0;
 
   null_value=0;
   if (!(res=args[0]->val_str(str)))
     goto null;
   use_as_buff= &tmp_value;
+  is_const= args[0]->const_item();
   for (i=1 ; i < arg_count ; i++)
   {
     if (res->length() == 0)
@@ -279,7 +281,7 @@ String *Item_func_concat::val_str(String *str)
 			    current_thd->variables.max_allowed_packet);
 	goto null;
       }
-      if (res->alloced_length() >= res->length()+res2->length())
+      if (!is_const && res->alloced_length() >= res->length()+res2->length())
       {						// Use old buffer
 	res->append(*res2);
       }
@@ -334,6 +336,7 @@ String *Item_func_concat::val_str(String *str)
 	res= &tmp_value;
 	use_as_buff=str;
       }
+      is_const= 0;
     }
   }
   res->set_charset(collation.collation);

From fd7d4d742993cb33641565e5f9923ae6a21fdb61 Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Sun, 28 May 2006 22:01:38 +0400
Subject: [PATCH 02/11] Fixed bug#15351: Wrong collation used for comparison of
 md5() and sha() argument can lead to a wrong result.

md5() and sha() functions treat their arguments as case sensitive strings.
But when they are compared their arguments were compared as a case
insensitive strings which leads to two functions with different arguments
and thus different results to being identical. This can lead to a wrong
decision made in the range optimizer and thus lead to a wrong result set.

Item_func_md5::fix_length_and_dec() and Item_func_sha::fix_length_and_dec()
functions now set binary collation on their arguments.


sql/item_strfunc.cc:
  Fixed bug#15351: Wrong collation used for comparison of md5() and sha()
  argument can lead to a wrong result.
  Item_func_md5::fix_length_and_dec() and Item_func_sha::fix_length_and_dec()
  functions now set binary collation on their arguments.
mysql-test/r/func_str.result:
   Added test case for the bug#15351: Wrong collation used for comparison of md5() and sha()
  argument can lead to a wrong result.
mysql-test/t/func_str.test:
  Added test case for the bug#15351: Wrong collation used for comparison of md5() and sha()
  argument can lead to a wrong result.
---
 mysql-test/r/func_str.result | 15 +++++++++++++++
 mysql-test/t/func_str.test   | 12 ++++++++++++
 sql/item_strfunc.cc          | 20 ++++++++++++++++++--
 3 files changed, 45 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/func_str.result b/mysql-test/r/func_str.result
index 0609624af18..24e6bb6f38a 100644
--- a/mysql-test/r/func_str.result
+++ b/mysql-test/r/func_str.result
@@ -1006,4 +1006,19 @@ NULL
 select ifnull(load_file("lkjlkj"),"it's null");
 ifnull(load_file("lkjlkj"),"it's null")
 it's null
+create table t1 (f1 varchar(4), f2 varchar(64), unique key k1 (f1,f2));
+insert into t1 values ( 'test',md5('test')), ('test', sha('test'));
+select * from t1 where f1='test' and (f2= md5("test") or f2= md5("TEST"));
+f1	f2
+test	098f6bcd4621d373cade4e832627b4f6
+select * from t1 where f1='test' and (f2= md5("TEST") or f2= md5("test"));
+f1	f2
+test	098f6bcd4621d373cade4e832627b4f6
+select * from t1 where f1='test' and (f2= sha("test") or f2= sha("TEST"));
+f1	f2
+test	a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
+select * from t1 where f1='test' and (f2= sha("TEST") or f2= sha("test"));
+f1	f2
+test	a94a8fe5ccb19ba61c4c0873d391e987982fbbd3
+drop table t1;
 End of 4.1 tests
diff --git a/mysql-test/t/func_str.test b/mysql-test/t/func_str.test
index c2f76dbac43..c36e15a08b9 100644
--- a/mysql-test/t/func_str.test
+++ b/mysql-test/t/func_str.test
@@ -669,4 +669,16 @@ drop table t1;
 select load_file("lkjlkj");
 select ifnull(load_file("lkjlkj"),"it's null");
 
+#
+# Bug#15351: Wrong collation used for comparison of md5() and sha()
+# parameter can lead to a wrong result.
+#
+create table t1 (f1 varchar(4), f2 varchar(64), unique key k1 (f1,f2));
+insert into t1 values ( 'test',md5('test')), ('test', sha('test'));
+select * from t1 where f1='test' and (f2= md5("test") or f2= md5("TEST"));
+select * from t1 where f1='test' and (f2= md5("TEST") or f2= md5("test"));
+select * from t1 where f1='test' and (f2= sha("test") or f2= sha("TEST"));
+select * from t1 where f1='test' and (f2= sha("TEST") or f2= sha("test"));
+drop table t1;
+
 --echo End of 4.1 tests
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index e74d0100b55..e817edac6c0 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -118,7 +118,15 @@ String *Item_func_md5::val_str(String *str)
 
 void Item_func_md5::fix_length_and_dec()
 {
-   max_length=32;
+  max_length=32;
+  /*
+    The MD5() function treats its parameter as being a case sensitive. Thus
+    we set binary collation on it so different instances of MD5() will be
+    compared properly.
+  */
+  args[0]->collation.set(
+      get_charset_by_csname(args[0]->collation.collation->csname,
+                            MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
 }
 
 
@@ -159,7 +167,15 @@ String *Item_func_sha::val_str(String *str)
 
 void Item_func_sha::fix_length_and_dec()
 {
-   max_length=SHA1_HASH_SIZE*2; // size of hex representation of hash
+  max_length=SHA1_HASH_SIZE*2; // size of hex representation of hash
+  /*
+    The SHA() function treats its parameter as being a case sensitive. Thus
+    we set binary collation on it so different instances of MD5() will be
+    compared properly.
+  */
+  args[0]->collation.set(
+      get_charset_by_csname(args[0]->collation.collation->csname,
+                            MY_CS_BINSORT,MYF(0)), DERIVATION_COERCIBLE);
 }
 
 

From 2264b644735e869fdbb16397c75170d86e2de127 Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Mon, 29 May 2006 00:32:59 +0400
Subject: [PATCH 03/11] Fixed bug#19225: unchecked error results in server
 crash

In multi-table delete a table for delete can't be used for selecting in
subselects. Appropriate error was raised but wasn't checked which leads to a
crash at the execution phase.

The mysql_execute_command() now checks for errors before executing select
for multi-delete.


mysql-test/t/multi_update.test:
  Added test case for bug#19225: unchecked error results in server crash
mysql-test/r/multi_update.result:
  Added test case for bug#19225: unchecked error results in server crash
sql/sql_parse.cc:
  Fixed bug#19225: unchecked error results in server crash
  The mysql_execute_command() now checks for errors before executing select for multi-delete.
---
 mysql-test/r/multi_update.result | 5 +++++
 mysql-test/t/multi_update.test   | 8 ++++++++
 sql/sql_parse.cc                 | 4 ++--
 3 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/multi_update.result b/mysql-test/r/multi_update.result
index dba10296063..ee62bd3bce6 100644
--- a/mysql-test/r/multi_update.result
+++ b/mysql-test/r/multi_update.result
@@ -475,3 +475,8 @@ aclid bigint, index idx_acl(aclid)
 insert into t2 values(1,null);
 delete t2, t1 from t2 left join t1 on (t2.aclid=t1.aclid) where t2.refid='1';
 drop table t1, t2;
+create table t1(a int);
+create table t2(a int);
+delete from t1,t2 using t1,t2 where t1.a=(select a from t1);
+ERROR HY000: You can't specify target table 't1' for update in FROM clause
+drop table t1, t2;
diff --git a/mysql-test/t/multi_update.test b/mysql-test/t/multi_update.test
index 27bdf4df3d7..e628e900c73 100644
--- a/mysql-test/t/multi_update.test
+++ b/mysql-test/t/multi_update.test
@@ -448,4 +448,12 @@ insert into t2 values(1,null);
 delete t2, t1 from t2 left join t1 on (t2.aclid=t1.aclid) where t2.refid='1';
 drop table t1, t2;
 
+#
+# Bug#19225: unchecked error leads to server crash
+#
+create table t1(a int);
+create table t2(a int);
+--error 1093
+delete from t1,t2 using t1,t2 where t1.a=(select a from t1);
+drop table t1, t2;
 # End of 4.1 tests
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index 51ef3f31b26..06005f31198 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -3047,8 +3047,8 @@ unsent_create_error:
       }
     }
 
-    if (!thd->is_fatal_error && (result= new multi_delete(thd,aux_tables,
-							  table_count)))
+    if (!res && !thd->is_fatal_error &&
+        (result= new multi_delete(thd,aux_tables, table_count)))
     {
       res= mysql_select(thd, &select_lex->ref_pointer_array,
 			select_lex->get_table_list(),

From c007dabaf62b7ac7eb41e2460b12d652b132bb7f Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Tue, 30 May 2006 00:36:48 +0400
Subject: [PATCH 04/11] Fixed bug#18360: Incorrect type coercion in IN()
 results in false comparison

The IN() function uses agg_cmp_type() to aggregate all types of its arguments
to find out some common type for comparisons. In this particular case the
char() and the int was aggregated to double because char() can contain values
like '1.5'. But all strings which do not start from a digit are converted to
0. thus 'a' and 'z' become equal.
This behaviour is reasonable when all function arguments are constants. But
when there is a field or an expression this can lead to false comparisons. In
this case it makes more sense to coerce constants to the type of the field
argument.

The agg_cmp_type() function now aggregates types of constant and non-constant
items separately. If some non-constant items will be found then their
aggregated type will be returned. Thus after the aggregation constants will be
coerced to the aggregated type.


mysql-test/t/func_in.test:
  Added test case for bug#18360: Incorrect type coercion in IN() results in false comparison.
mysql-test/r/func_in.result:
  Added test case for bug#18360: Incorrect type coercion in IN() results in false comparison.
sql/item_cmpfunc.cc:
  Fixed bug#18360: Incorrect type coercion in IN() results in false comparison.
  The agg_cmp_type() function now aggregates types of constant and non-constant
  items separately. If some non-constant items will be found then their
  aggregated type will be returned. Thus after the aggregation constants will
  be coerced to the aggregated type.
---
 mysql-test/r/func_in.result | 21 +++++++++++++++++++++
 mysql-test/t/func_in.test   | 12 ++++++++++++
 sql/item_cmpfunc.cc         | 37 +++++++++++++++++++++++++++++++++++--
 3 files changed, 68 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/func_in.result b/mysql-test/r/func_in.result
index 3cf2afc83d1..0632dddb87e 100644
--- a/mysql-test/r/func_in.result
+++ b/mysql-test/r/func_in.result
@@ -202,3 +202,24 @@ select count(*) from t1 where id not in (1,2);
 count(*)
 1
 drop table t1;
+create table t1 (f1 char(1), f2 int);
+insert into t1 values (1,0),('a',1),('z',2);
+select f1 from t1 where f1 in (1,'z');
+f1
+1
+z
+select f2 from t1 where f2 in (1,'z');
+f2
+0
+1
+select f1 from t1 where 'z' in (1,f1);
+f1
+z
+select * from t1 where 'z' in (f2,f1);
+f1	f2
+z	2
+select * from t1 where 1 in (f2,f1);
+f1	f2
+1	0
+a	1
+drop table t1;
diff --git a/mysql-test/t/func_in.test b/mysql-test/t/func_in.test
index 2ffe5a2d5f7..3481f2c7b11 100644
--- a/mysql-test/t/func_in.test
+++ b/mysql-test/t/func_in.test
@@ -109,4 +109,16 @@ select count(*) from t1 where id not in (1);
 select count(*) from t1 where id not in (1,2);
 drop table t1;
 
+#
+# Bug#18360 Incorrect type coercion in IN() results in false comparison
+#
+create table t1 (f1 char(1), f2 int);
+insert into t1 values (1,0),('a',1),('z',2);
+select f1 from t1 where f1 in (1,'z');
+select f2 from t1 where f2 in (1,'z');
+select f1 from t1 where 'z' in (1,f1);
+select * from t1 where 'z' in (f2,f1);
+select * from t1 where 1 in (f2,f1);
+drop table t1;
+
 # End of 4.1 tests
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index 3c41fb56d89..bfbb3355004 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -58,12 +58,45 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
   }
 }
 
+
+/*
+  Aggregates result types from the array of items.
+
+  SYNOPSIS:
+    agg_cmp_type()
+    type   [out] the aggregated type
+    items        array of items to aggregate the type from
+    nitems       number of items in the array
+
+  DESCRIPTION
+    This function aggregates result types from the array of items. Found type
+    supposed to be used later for comparison of values of these items.
+    Aggregation itself is performed by the item_cmp_type() function.
+
+  NOTES
+    Aggregation rules:
+    If all items are constants the type will be aggregated from all items.
+    If there are some non-constant items then only types of non-constant
+    items will be used for aggregation.
+*/
 static void agg_cmp_type(Item_result *type, Item **items, uint nitems)
 {
   uint i;
   type[0]= items[0]->result_type();
-  for (i=1 ; i < nitems ; i++)
-    type[0]= item_cmp_type(type[0], items[i]->result_type());
+  /* Reset to 0 on first occurence of non-const item. 1 otherwise */
+  bool is_const= items[0]->const_item();
+
+  for (i= 1 ; i < nitems ; i++)
+  {
+    if (!items[i]->const_item())
+    {
+      type[0]= is_const ? items[i]->result_type() :
+                 item_cmp_type(type[0], items[i]->result_type());
+      is_const= 0;
+    }
+    else if (is_const)
+      type[0]= item_cmp_type(type[0], items[i]->result_type());
+  }
 }
 
 static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,

From 3390eaa08582d9c0d0e12db7259ae00ede9741e7 Mon Sep 17 00:00:00 2001
From: unknown <gkodinov@mysql.com>
Date: Fri, 2 Jun 2006 12:04:03 +0300
Subject: [PATCH 05/11] Bug #4981: 4.x and 5.x produce non-optimal execution
 path,         3.23 regression test failure

The member SEL_ARG::min_flag was not initialized,
due to which the condition for no GEOM_FLAG in function
key_or did not choose "Range checked for each record" as
the correct access method.


mysql-test/r/select.result:
  testcase for 'Range checked' access method
mysql-test/t/select.test:
  testcase for 'Range checked' access method
sql/opt_range.cc:
  All of the class members initialized
---
 mysql-test/r/select.result | 14 ++++++++++++++
 mysql-test/t/select.test   | 14 ++++++++++++++
 sql/opt_range.cc           |  2 +-
 3 files changed, 29 insertions(+), 1 deletion(-)

diff --git a/mysql-test/r/select.result b/mysql-test/r/select.result
index b80ca2b195e..5511a4bb66b 100644
--- a/mysql-test/r/select.result
+++ b/mysql-test/r/select.result
@@ -2714,3 +2714,17 @@ select * from t1 where f1 in (select f3 from t2 where (f3,f4)= (select f3,f4 fro
 f1	f2
 1	1
 drop table t1,t2;
+CREATE TABLE t1(a int, b int, c int, KEY b(b), KEY c(c));
+insert into t1 values (1,0,0),(2,0,0);
+CREATE TABLE t2 (a int, b varchar(2), c varchar(2), PRIMARY KEY(a));
+insert into t2 values (1,'',''), (2,'','');
+CREATE TABLE t3 (a int, b int, PRIMARY KEY (a,b), KEY a (a), KEY b (b));
+insert into t3 values (1,1),(1,2);
+explain select straight_join DISTINCT t2.a,t2.b, t1.c from t1, t3, t2 
+where (t1.c=t2.a or (t1.c=t3.a and t2.a=t3.b)) and t1.b=556476786 and 
+t2.b like '%%' order by t2.b limit 0,1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ref	b,c	b	5	const	1	Using where; Using temporary; Using filesort
+1	SIMPLE	t3	index	PRIMARY,a,b	PRIMARY	8	NULL	2	Using index
+1	SIMPLE	t2	ALL	PRIMARY	NULL	NULL	NULL	2	Range checked for each record (index map: 0x1)
+DROP TABLE t1,t2,t3;
diff --git a/mysql-test/t/select.test b/mysql-test/t/select.test
index 996d5854854..3dcc16f1625 100644
--- a/mysql-test/t/select.test
+++ b/mysql-test/t/select.test
@@ -2248,4 +2248,18 @@ insert into t2 values(1,1);
 select * from t1 where f1 in (select f3 from t2 where (f3,f4)= (select f3,f4 from t2)); 
 drop table t1,t2;
 
+#
+# Bug #4981: 4.x and 5.x produce non-optimal execution path, 3.23 regression test failure
+#
+CREATE TABLE t1(a int, b int, c int, KEY b(b), KEY c(c));
+insert into t1 values (1,0,0),(2,0,0);
+CREATE TABLE t2 (a int, b varchar(2), c varchar(2), PRIMARY KEY(a));
+insert into t2 values (1,'',''), (2,'','');
+CREATE TABLE t3 (a int, b int, PRIMARY KEY (a,b), KEY a (a), KEY b (b));
+insert into t3 values (1,1),(1,2);
+# must have "range checked" for t2
+explain select straight_join DISTINCT t2.a,t2.b, t1.c from t1, t3, t2 
+ where (t1.c=t2.a or (t1.c=t3.a and t2.a=t3.b)) and t1.b=556476786 and 
+       t2.b like '%%' order by t2.b limit 0,1;
+DROP TABLE t1,t2,t3;
 # End of 4.1 tests
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index 71f937f90c6..67141aab6ce 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -64,7 +64,7 @@ public:
 	  uint8 min_flag, uint8 max_flag, uint8 maybe_flag);
   SEL_ARG(enum Type type_arg)
     :elements(1),use_count(1),left(0),next_key_part(0),color(BLACK),
-     type(type_arg)
+     type(type_arg),min_flag(0)
   {}
   inline bool is_same(SEL_ARG *arg)
   {

From e3e0658779bffacd5323efb54ecb7f42ded19231 Mon Sep 17 00:00:00 2001
From: unknown <igor@rurik.mysql.com>
Date: Fri, 2 Jun 2006 14:14:57 -0700
Subject: [PATCH 06/11] Fixed bug #18206. The bug report revealed two problems
 related to min/max optimization: 1. If the length of a constant key used in a
 SARGable condition for for the MIN/MAX fields is greater than the length of
 the field an unwanted warning on key truncation is issued; 2. If MIN/MAX
 optimization is applied to a partial index, like INDEX(b(4)) than can lead to
 returning a wrong result set.

mysql-test/r/func_group.result:
  Added test cases for bug #18206.
mysql-test/t/func_group.test:
  Added test cases for bug #18206.
sql/opt_sum.cc:
  Fixed bug #18206.
  Suppressed the warning about data truncation when store_val_in_field
  was used to store keys for the field used in MIN/MAX optimization.
  Blocked MIN/MAX optimization for partial keys, such as in INDEX(b(4)).
sql/sql_select.cc:
  Fixed bug #18206.
  Added a parameter for the function store_val_in_field allowing to
  control setting warnings about data truncation in the function.
sql/sql_select.h:
  Fixed bug #18206.
  Added a parameter for the function store_val_in_field allowing to
  control setting warnings about data truncation in the function.
---
 mysql-test/r/func_group.result | 24 ++++++++++++++++++++++++
 mysql-test/t/func_group.test   | 19 +++++++++++++++++++
 sql/opt_sum.cc                 | 17 ++++++++++++++---
 sql/sql_select.cc              |  6 +++---
 sql/sql_select.h               |  2 +-
 5 files changed, 61 insertions(+), 7 deletions(-)

diff --git a/mysql-test/r/func_group.result b/mysql-test/r/func_group.result
index 67966b999d4..ffa68f279f3 100644
--- a/mysql-test/r/func_group.result
+++ b/mysql-test/r/func_group.result
@@ -916,3 +916,27 @@ select count(*), min(7), max(7) from t2m, t1i;
 count(*)	min(7)	max(7)
 0	NULL	NULL
 drop table t1m, t1i, t2m, t2i;
+CREATE TABLE t1 (id int PRIMARY KEY, b char(3), INDEX(b));
+INSERT INTO t1 VALUES (1,'xx'), (2,'aa');
+SELECT * FROM t1;
+id	b
+1	xx
+2	aa
+SELECT MAX(b) FROM t1 WHERE b < 'ppppp';
+MAX(b)
+aa
+SHOW WARNINGS;
+Level	Code	Message
+SELECT MAX(b) FROM t1 WHERE b < 'pp';
+MAX(b)
+aa
+DROP TABLE t1;
+CREATE TABLE t1 (id int PRIMARY KEY, b char(16), INDEX(b(4)));
+INSERT INTO t1 VALUES (1, 'xxxxbbbb'), (2, 'xxxxaaaa');
+SELECT MAX(b) FROM t1;
+MAX(b)
+xxxxbbbb
+EXPLAIN SELECT MAX(b) FROM t1;
+id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
+1	SIMPLE	t1	ALL	NULL	NULL	NULL	NULL	2	
+DROP TABLE t1;
diff --git a/mysql-test/t/func_group.test b/mysql-test/t/func_group.test
index dc647dbcfeb..f8a3ed0f25e 100644
--- a/mysql-test/t/func_group.test
+++ b/mysql-test/t/func_group.test
@@ -598,4 +598,23 @@ select count(*), min(7), max(7) from t2m, t1i;
 
 drop table t1m, t1i, t2m, t2i;
 
+#
+# Bug #18206: min/max optimization cannot be applied to partial index
+#
+
+CREATE TABLE t1 (id int PRIMARY KEY, b char(3), INDEX(b));
+INSERT INTO t1 VALUES (1,'xx'), (2,'aa');
+SELECT * FROM t1;
+
+SELECT MAX(b) FROM t1 WHERE b < 'ppppp';
+SHOW WARNINGS;
+SELECT MAX(b) FROM t1 WHERE b < 'pp';
+DROP TABLE t1;
+
+CREATE TABLE t1 (id int PRIMARY KEY, b char(16), INDEX(b(4)));
+INSERT INTO t1 VALUES (1, 'xxxxbbbb'), (2, 'xxxxaaaa');
+SELECT MAX(b) FROM t1;
+EXPLAIN SELECT MAX(b) FROM t1;
+DROP TABLE t1;
+
 # End of 4.1 tests
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index cfb5b3695a3..82211120c57 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -543,6 +543,10 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
       break;                        // Found a part od the key for the field
   }
 
+#if 0
+  if (part->length != (((Item_field*) args[0])->field)->field_length)
+    return 0;
+#endif
   bool is_field_part= part == field_part;
   if (!(is_field_part || eq_type))
     return 0;
@@ -582,7 +586,8 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
     }
     else
     {
-      store_val_in_field(part->field, args[between && max_fl ? 2 : 1]);
+      store_val_in_field(part->field, args[between && max_fl ? 2 : 1],
+                         CHECK_FIELD_IGNORE);
       if (part->null_bit) 
         *key_ptr++= (byte) test(part->field->is_null());
       part->field->get_key_image((char*) key_ptr, part->length,
@@ -638,6 +643,8 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
         field BETWEEN const1 AND const2
      3. all references to the columns from the same table as column field
         occur only in conjucts mentioned above.
+     4. each of k first components the index is not partial, i.e. is not
+        defined on a fixed length proper prefix of the field.
 
      If such an index exists the function through the ref parameter
      returns the key value to find max/min for the field using the index,
@@ -647,8 +654,8 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
       of the whole search key)
 
   NOTE
-   This function may set table->key_read to 1, which must be reset after
-   index is used! (This can only happen when function returns 1)
+    This function may set table->key_read to 1, which must be reset after
+    index is used! (This can only happen when function returns 1)
 
   RETURN
     0   Index can not be used to optimize MIN(field)/MAX(field)
@@ -682,6 +689,10 @@ static bool find_key_for_maxmin(bool max_fl, TABLE_REF *ref,
       if (!(table->file->index_flags(idx, jdx, 0) & HA_READ_ORDER))
         return 0;
 
+        /* Check whether the index component is partial */
+      if (part->length < table->field[part->fieldnr-1]->pack_length())
+        break;
+
       if (field->eq(part->field))
       {
         ref->key= idx;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 57fb9738612..5a7e9e52aed 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -3434,7 +3434,7 @@ get_store_key(THD *thd, KEYUSE *keyuse, table_map used_tables,
 */
 
 bool
-store_val_in_field(Field *field,Item *item)
+store_val_in_field(Field *field, Item *item, enum_check_fields check_flag)
 {
   bool error;
   THD *thd=current_thd;
@@ -3445,7 +3445,7 @@ store_val_in_field(Field *field,Item *item)
     with select_insert, which make count_cuted_fields= 1
    */
   enum_check_fields old_count_cuted_fields= thd->count_cuted_fields;
-  thd->count_cuted_fields= CHECK_FIELD_WARN;
+  thd->count_cuted_fields= check_flag;
   error= item->save_in_field(field, 1);
   thd->count_cuted_fields= old_count_cuted_fields;
   return error || cuted_fields != thd->cuted_fields;
@@ -7097,7 +7097,7 @@ static bool test_if_ref(Item_field *left_item,Item *right_item)
 	    field->real_type() != FIELD_TYPE_VAR_STRING &&
 	    (field->type() != FIELD_TYPE_FLOAT || field->decimals() == 0))
 	{
-	  return !store_val_in_field(field,right_item);
+	  return !store_val_in_field(field, right_item, CHECK_FIELD_WARN);
 	}
       }
     }
diff --git a/sql/sql_select.h b/sql/sql_select.h
index 94cc8839466..75cd0b4d797 100644
--- a/sql/sql_select.h
+++ b/sql/sql_select.h
@@ -335,7 +335,7 @@ extern const char *join_type_str[];
 void TEST_join(JOIN *join);
 
 /* Extern functions in sql_select.cc */
-bool store_val_in_field(Field *field,Item *val);
+bool store_val_in_field(Field *field, Item *val, enum_check_fields check_flag);
 TABLE *create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
 			ORDER *group, bool distinct, bool save_sum_fields,
 			ulong select_options, ha_rows rows_limit,

From e815f93bbfffd0ddc2c54df1b32c307b1f19c4b7 Mon Sep 17 00:00:00 2001
From: unknown <igor@rurik.mysql.com>
Date: Fri, 2 Jun 2006 19:15:32 -0700
Subject: [PATCH 07/11] Cleanup for the fix of bug 18206.

sql/opt_sum.cc:
  Cleanup
---
 sql/opt_sum.cc | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
index 82211120c57..97e271121d3 100644
--- a/sql/opt_sum.cc
+++ b/sql/opt_sum.cc
@@ -543,10 +543,6 @@ static bool matching_cond(bool max_fl, TABLE_REF *ref, KEY *keyinfo,
       break;                        // Found a part od the key for the field
   }
 
-#if 0
-  if (part->length != (((Item_field*) args[0])->field)->field_length)
-    return 0;
-#endif
   bool is_field_part= part == field_part;
   if (!(is_field_part || eq_type))
     return 0;

From 47311e8e878a0f049c3f3b2a1c1dea454800d70a Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Tue, 13 Jun 2006 19:09:24 +0400
Subject: [PATCH 08/11] Fixed bug#16377: result of DATE/TIME functions were
 compared as strings which can lead to a wrong result.

All date/time functions has the STRING result type thus their results are
compared as strings. The string date representation allows a user to skip
some of leading zeros. This can lead to wrong comparison result if a date/time
function result is compared to such a string constant.

The idea behind this bug fix is to compare results of date/time functions
and data/time constants as ints, because that date/time representation is
more exact. To achieve this the agg_cmp_type() is changed to take in the
account that a date/time field or an date/time item should be compared
as ints.

This bug fix is partially back ported from 5.0.

The agg_cmp_type() function now accepts THD as one of parameters.
In addition, it now checks if a date/time field/function is present in the
list. If so, it tries to coerce all constants to INT to make date/time
comparison return correct result. The field for the constant coercion is
taken from the Item_field or constructed from the Item_func. In latter case
the constructed field will be freed after conversion of all constant items.
Otherwise the result is same as before - aggregated with help of the
item_cmp_type() function.

From the Item_func_between::fix_length_and_dec() function removed the part
which was converting date/time constants to int if possible. Now this is
done by the agg_cmp_type() function.

The new function result_as_longlong() is added to the Item class.
It indicates that the item is a date/time item and result of it can be
compared as int. Such items are date/time fields/functions.

Correct val_int() methods are implemented for classes Item_date_typecast,
Item_func_makedate, Item_time_typecast, Item_datetime_typecast. All these
classes are derived from Item_str_func and Item_str_func::val_int() converts
its string value to int without regard to the date/time type of these items.

Arg_comparator::set_compare_func() and Arg_comparator::set_cmp_func()
functions are changed to substitute result type of an item with the INT_RESULT
if the item is a date/time item and another item is a constant. This is done
to get a correct result of comparisons like date_time_function() = string_constant.


mysql-test/r/cast.result:
  Fixed wrong test case result after bug fix#16377.
sql/item_timefunc.h:
  Fixed bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
  The result_as_longlong() function is set to return TRUE for these classes:
  Item_date, Item_date_func, Item_func_curtime, Item_func_sec_to_time,
  Item_date_typecast, Item_time_typecast, Item_datetime_typecast,
  Item_func_makedate.
sql/item_timefunc.cc:
  Fixed bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.Correct val_int() methods are implemented for classes Item_date_typecast,
  Item_func_makedate, Item_time_typecast, Item_datetime_typecast.
sql/item_cmpfunc.h:
  Fixed bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
  Arg_comparator::set_compare_func() and Arg_comparator::set_cmp_func()
  functions are changed to substitute result type of an item with the INT_RESULT
  if the item is a date/time item and another item is a constant.
sql/field.cc:
  Fixed bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
  Field::set_warning(), Field::set_datetime_warning() now use current_thd to get thd if table isn't set.
sql/item_cmpfunc.cc:
  Fixed bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
  The agg_cmp_type() function now accepts THD as one of parameters.
  In addition, it now checks if a date/time field/function is present in the
  list. If so, it tries to coerce all constants to INT to make date/time
  comparison return correct result. The field for the constant coercion is
  taken from the Item_field or constructed from the Item_func. In latter case
  the constructed field will be freed after conversion of all constant items.
  Otherwise the result is same as before - aggregated with help of the
  item_cmp_type() function.
sql/item.h:
  The new function result_as_longlong() is added to the Item class.
  It indicates that the item is a date/time item and result of it can be
  compared as int. Such items are date/time fields/functions.
mysql-test/t/func_time.test:
  Added test case fot bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
mysql-test/r/func_time.result:
  Added test case fot bug#16377: result of DATE/TIME functions were compared as strings which
  can lead to a wrong result.
---
 mysql-test/r/cast.result      |   2 +-
 mysql-test/r/func_time.result |  41 +++++++++
 mysql-test/t/func_time.test   |  20 +++++
 sql/field.cc                  |  16 ++--
 sql/item.h                    |  16 ++++
 sql/item_cmpfunc.cc           | 154 +++++++++++++++++++++++++++-------
 sql/item_cmpfunc.h            |  14 +++-
 sql/item_timefunc.cc          |  60 +++++++++++++
 sql/item_timefunc.h           |  12 +++
 9 files changed, 293 insertions(+), 42 deletions(-)

diff --git a/mysql-test/r/cast.result b/mysql-test/r/cast.result
index 68687670e17..2538fbfd61d 100644
--- a/mysql-test/r/cast.result
+++ b/mysql-test/r/cast.result
@@ -192,7 +192,7 @@ cast("2001-1-1" as datetime) = "2001-01-01 00:00:00"
 1
 select cast("1:2:3" as TIME) = "1:02:03";
 cast("1:2:3" as TIME) = "1:02:03"
-0
+1
 select cast(NULL as DATE);
 cast(NULL as DATE)
 NULL
diff --git a/mysql-test/r/func_time.result b/mysql-test/r/func_time.result
index 02f3d2f7273..93d4542bf5b 100644
--- a/mysql-test/r/func_time.result
+++ b/mysql-test/r/func_time.result
@@ -630,3 +630,44 @@ select monthname(str_to_date(null, '%m')), monthname(str_to_date(null, '%m')),
 monthname(str_to_date(1, '%m')), monthname(str_to_date(0, '%m'));
 monthname(str_to_date(null, '%m'))	monthname(str_to_date(null, '%m'))	monthname(str_to_date(1, '%m'))	monthname(str_to_date(0, '%m'))
 NULL	NULL	January	NULL
+create table t1(f1 date, f2 time, f3 datetime);
+insert into t1 values ("2006-01-01", "12:01:01", "2006-01-01 12:01:01");
+insert into t1 values ("2006-01-02", "12:01:02", "2006-01-02 12:01:02");
+select f1 from t1 where f1 between "2006-1-1" and 20060101;
+f1
+2006-01-01
+select f1 from t1 where f1 between "2006-1-1" and "2006.1.1";
+f1
+2006-01-01
+select f1 from t1 where date(f1) between "2006-1-1" and "2006.1.1";
+f1
+2006-01-01
+select f2 from t1 where f2 between "12:1:2" and "12:2:2";
+f2
+12:01:02
+select f2 from t1 where time(f2) between "12:1:2" and "12:2:2";
+f2
+12:01:02
+select f3 from t1 where f3 between "2006-1-1 12:1:1" and "2006-1-1 12:1:2";
+f3
+2006-01-01 12:01:01
+select f3 from t1 where timestamp(f3) between "2006-1-1 12:1:1" and "2006-1-1 12:1:2";
+f3
+2006-01-01 12:01:01
+select f1 from t1 where "2006-1-1" between f1 and f3;
+f1
+2006-01-01
+select f1 from t1 where "2006-1-1" between date(f1) and date(f3);
+f1
+2006-01-01
+select f1 from t1 where "2006-1-1" between f1 and 'zzz';
+f1
+Warnings:
+Warning	1292	Truncated incorrect date value: 'zzz'
+select f1 from t1 where makedate(2006,1) between date(f1) and date(f3);
+f1
+2006-01-01
+select f1 from t1 where makedate(2006,2) between date(f1) and date(f3);
+f1
+2006-01-02
+drop table t1;
diff --git a/mysql-test/t/func_time.test b/mysql-test/t/func_time.test
index 01e4e47d318..5e0b35522cf 100644
--- a/mysql-test/t/func_time.test
+++ b/mysql-test/t/func_time.test
@@ -322,4 +322,24 @@ select last_day('2005-01-00');
 select monthname(str_to_date(null, '%m')), monthname(str_to_date(null, '%m')),
        monthname(str_to_date(1, '%m')), monthname(str_to_date(0, '%m'));
 
+#
+# Bug#16377 result of DATE/TIME functions were compared as strings which
+#           can lead to a wrong result.
+#
+create table t1(f1 date, f2 time, f3 datetime);
+insert into t1 values ("2006-01-01", "12:01:01", "2006-01-01 12:01:01");
+insert into t1 values ("2006-01-02", "12:01:02", "2006-01-02 12:01:02");
+select f1 from t1 where f1 between "2006-1-1" and 20060101;
+select f1 from t1 where f1 between "2006-1-1" and "2006.1.1";
+select f1 from t1 where date(f1) between "2006-1-1" and "2006.1.1";
+select f2 from t1 where f2 between "12:1:2" and "12:2:2";
+select f2 from t1 where time(f2) between "12:1:2" and "12:2:2";
+select f3 from t1 where f3 between "2006-1-1 12:1:1" and "2006-1-1 12:1:2";
+select f3 from t1 where timestamp(f3) between "2006-1-1 12:1:1" and "2006-1-1 12:1:2";
+select f1 from t1 where "2006-1-1" between f1 and f3;
+select f1 from t1 where "2006-1-1" between date(f1) and date(f3);
+select f1 from t1 where "2006-1-1" between f1 and 'zzz';
+select f1 from t1 where makedate(2006,1) between date(f1) and date(f3);
+select f1 from t1 where makedate(2006,2) between date(f1) and date(f3);
+drop table t1;
 # End of 4.1 tests
diff --git a/sql/field.cc b/sql/field.cc
index a64eaad7308..ec4d4b4e4f5 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -6841,7 +6841,11 @@ create_field::create_field(Field *old_field,Field *orig_field)
 bool 
 Field::set_warning(const uint level, const uint code, int cuted_increment)
 {
-  THD *thd= table->in_use;
+  /*
+    If this field was created only for type conversion purposes it
+    will have table == NULL.
+  */
+  THD *thd= table ? table->in_use : current_thd;
   if (thd->count_cuted_fields)
   {
     thd->cuted_fields+= cuted_increment;
@@ -6876,7 +6880,8 @@ Field::set_datetime_warning(const uint level, const uint code,
                             timestamp_type ts_type, int cuted_increment)
 {
   if (set_warning(level, code, cuted_increment))
-    make_truncated_value_warning(table->in_use, str, str_length, ts_type);
+    make_truncated_value_warning(table ? table->in_use : current_thd,
+                                 str, str_length, ts_type);
 }
 
 
@@ -6905,8 +6910,8 @@ Field::set_datetime_warning(const uint level, const uint code,
   {
     char str_nr[22];
     char *str_end= longlong10_to_str(nr, str_nr, -10);
-    make_truncated_value_warning(table->in_use, str_nr, str_end - str_nr, 
-                                 ts_type);
+    make_truncated_value_warning(table ? table->in_use : current_thd,
+                                 str_nr, str_end - str_nr, ts_type);
   }
 }
 
@@ -6935,7 +6940,8 @@ Field::set_datetime_warning(const uint level, const uint code,
     /* DBL_DIG is enough to print '-[digits].E+###' */
     char str_nr[DBL_DIG + 8];
     uint str_len= my_sprintf(str_nr, (str_nr, "%g", nr));
-    make_truncated_value_warning(table->in_use, str_nr, str_len, ts_type);
+    make_truncated_value_warning(table ? table->in_use : current_thd,
+                                 str_nr, str_len, ts_type);
   }
 }
 
diff --git a/sql/item.h b/sql/item.h
index 66da7ad4e74..eca8ee184a1 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -327,6 +327,14 @@ public:
     cleanup();
     delete this;
   }
+  /*
+    result_as_longlong() must return TRUE for Items representing DATE/TIME
+    functions and DATE/TIME table fields.
+    Those Items have result_type()==STRING_RESULT (and not INT_RESULT), but
+    their values should be compared as integers (because the integer
+    representation is more precise than the string one).
+  */
+  virtual bool result_as_longlong() { return FALSE; }
 };
 
 
@@ -450,6 +458,10 @@ public:
   Item *get_tmp_table_item(THD *thd);
   void cleanup();
   inline uint32 max_disp_length() { return field->max_length(); }
+  bool result_as_longlong()
+  {
+    return field->can_be_compared_as_longlong();
+  }
   friend class Item_default_value;
   friend class Item_insert_value;
   friend class st_select_lex_unit;
@@ -973,6 +985,10 @@ public:
   }
   Item *real_item() { return *ref; }
   void print(String *str);
+  bool result_as_longlong()
+  {
+    return (*ref)->result_as_longlong();
+  }
 };
 
 
diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index bfbb3355004..e92e1d30ca4 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -25,6 +25,8 @@
 #include <m_ctype.h>
 #include "sql_select.h"
 
+static bool convert_constant_item(THD *thd, Field *field, Item **item);
+
 static Item_result item_store_type(Item_result a,Item_result b)
 {
   if (a == STRING_RESULT || b == STRING_RESULT)
@@ -64,6 +66,7 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
 
   SYNOPSIS:
     agg_cmp_type()
+    thd          thread handle
     type   [out] the aggregated type
     items        array of items to aggregate the type from
     nitems       number of items in the array
@@ -78,24 +81,133 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
     If all items are constants the type will be aggregated from all items.
     If there are some non-constant items then only types of non-constant
     items will be used for aggregation.
+    If there are DATE/TIME fields/functions in the list and no string
+    fields/functions in the list then:
+      The INT_RESULT type will be used for aggregation instead of orginal
+      result type of any DATE/TIME field/function in the list
+      All constant items in the list will be converted to a DATE/TIME using
+      found field or result field of found function.
+
+    Implementation notes:
+      The code is equvalent to:
+      1. Check the list for presense of a STRING field/function.
+         Collect the is_const flag.
+      2. Get a Field* object to use for type coercion
+      3. Perform type conversion.
+      1 and 2 are implemented in 2 loops. The first searches for a DATE/TIME
+      field/function and checks presense of a STRING field/function.
+      The second loop works only if a DATE/TIME field/function is found.
+      It checks presense of a STRING field/function in the rest of the list.
+
+  TODO
+    1) The current implementation can produce false comparison results for
+    expressions like:
+      date_time_field BETWEEN string_field_with_dates AND string_constant
+    if the string_constant will omit some of leading zeroes.
+    In order to fully implement correct comparison of DATE/TIME the new
+    DATETIME_RESULT result type should be introduced and agg_cmp_type()
+    should return the DATE/TIME field used for the conversion. Later
+    this field can be used by comparison functions like Item_func_between to
+    convert string values to ints on the fly and thus return correct results.
+    This modification will affect functions BETWEEN, IN and CASE.
+
+    2) If in the list a DATE field/function and a DATETIME field/function
+    are present in the list then the first found field/function will be
+    used for conversion. This may lead to wrong results and probably should
+    be fixed.
 */
-static void agg_cmp_type(Item_result *type, Item **items, uint nitems)
+
+static void agg_cmp_type(THD *thd, Item_result *type, Item **items, uint nitems)
 {
   uint i;
-  type[0]= items[0]->result_type();
+  Item::Type res;
+  char *buff= NULL;
+  uchar null_byte;
+  Field *field= NULL;
+
+  /* Search for date/time fields/functions */
+  for (i= 0; i < nitems; i++)
+  {
+    if (!items[i]->result_as_longlong())
+    {
+      /* Do not convert anything if a string field/function is present */
+      if (!items[i]->const_item() && items[i]->result_type() == STRING_RESULT)
+      {
+        i= nitems;
+        break;
+      }
+      continue;
+    }
+    if ((res= items[i]->real_item()->type()) == Item::FIELD_ITEM)
+    {
+      field= ((Item_field *)items[i]->real_item())->field;
+      break;
+    }
+    else if (res == Item::FUNC_ITEM)
+    {
+      field= items[i]->tmp_table_field_from_field_type(0);
+      if (field)
+        buff= alloc_root(thd->mem_root, field->max_length());
+      if (!buff || !field)
+      {
+        if (field)
+          delete field;
+        if (buff)
+          my_free(buff, MYF(MY_WME));
+        field= 0;
+      }
+      else
+        field->move_field(buff, &null_byte, 0);
+      break;
+    }
+  }
+  if (field)
+  {
+    /* Check the rest of the list for presense of a string field/function. */
+    for (i++ ; i < nitems; i++)
+    {
+      if (!items[i]->const_item() && items[i]->result_type() == STRING_RESULT &&
+          !items[i]->result_as_longlong())
+      {
+        field= 0;
+        break;
+      }
+    }
+  }
   /* Reset to 0 on first occurence of non-const item. 1 otherwise */
   bool is_const= items[0]->const_item();
+  /*
+    If the first item is a date/time function then its result should be
+    compared as int
+  */
+  if (field)
+  {
+    /* Suppose we are comparing dates and some non-constant items are present. */
+    type[0]= INT_RESULT;
+    is_const= 0;
+  }
+  else
+    type[0]= items[0]->result_type();
 
-  for (i= 1 ; i < nitems ; i++)
+  for (i= 0; i < nitems ; i++)
   {
     if (!items[i]->const_item())
     {
-      type[0]= is_const ? items[i]->result_type() :
-                 item_cmp_type(type[0], items[i]->result_type());
+      Item_result result= field && items[i]->result_as_longlong() ?
+                            INT_RESULT : items[i]->result_type();
+      type[0]= is_const ? result : item_cmp_type(type[0], result);
       is_const= 0;
     }
     else if (is_const)
       type[0]= item_cmp_type(type[0], items[i]->result_type());
+    else if (field)
+      convert_constant_item(thd, field, &items[i]);
+  }
+
+  if (res == Item::FUNC_ITEM && field)
+  {
+    delete field;
+    my_free(buff, MYF(MY_WME));
   }
 }
 
@@ -929,31 +1041,9 @@ void Item_func_between::fix_length_and_dec()
   */
   if (!args[0] || !args[1] || !args[2])
     return;
-  agg_cmp_type(&cmp_type, args, 3);
-  if (cmp_type == STRING_RESULT &&
-      agg_arg_charsets(cmp_collation, args, 3, MY_COLL_CMP_CONV))
-    return;
-
-  /*
-    Make a special case of compare with date/time and longlong fields.
-    They are compared as integers, so for const item this time-consuming
-    conversion can be done only once, not for every single comparison
-  */
-  if (args[0]->type() == FIELD_ITEM)
-  {
-    Field *field=((Item_field*) args[0])->field;
-    if (field->can_be_compared_as_longlong())
-    {
-      /*
-        The following can't be recoded with || as convert_constant_item
-        changes the argument
-      */
-      if (convert_constant_item(thd, field,&args[1]))
-	cmp_type=INT_RESULT;			// Works for all types.
-      if (convert_constant_item(thd, field,&args[2]))
-	cmp_type=INT_RESULT;			// Works for all types.
-    }
-  }
+  agg_cmp_type(thd, &cmp_type, args, 3);
+  if (cmp_type == STRING_RESULT)
+      agg_arg_charsets(cmp_collation, args, 3, MY_COLL_CMP_CONV);
 }
 
 
@@ -1477,7 +1567,7 @@ void Item_func_case::fix_length_and_dec()
     for (nagg= 0; nagg < ncases/2 ; nagg++)
       agg[nagg+1]= args[nagg*2];
     nagg++;
-    agg_cmp_type(&cmp_type, agg, nagg);
+    agg_cmp_type(current_thd, &cmp_type, agg, nagg);
     if ((cmp_type == STRING_RESULT) &&
         agg_arg_charsets(cmp_collation, agg, nagg, MY_COLL_CMP_CONV))
     return;
@@ -1958,7 +2048,7 @@ void Item_func_in::fix_length_and_dec()
   uint const_itm= 1;
   THD *thd= current_thd;
   
-  agg_cmp_type(&cmp_type, args, arg_count);
+  agg_cmp_type(thd, &cmp_type, args, arg_count);
 
   if (cmp_type == STRING_RESULT &&
       agg_arg_charsets(cmp_collation, args, arg_count, MY_COLL_CMP_CONV))
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index ade09113c63..08d9de6ffd6 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -43,8 +43,11 @@ public:
   int set_compare_func(Item_bool_func2 *owner, Item_result type);
   inline int set_compare_func(Item_bool_func2 *owner_arg)
   {
-    return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(),
-						     (*b)->result_type()));
+    Item_result ar= (*a)->result_as_longlong() && (*b)->const_item() ?
+                      INT_RESULT : (*a)->result_type();
+    Item_result br= (*b)->result_as_longlong() && (*a)->const_item() ?
+                      INT_RESULT : (*b)->result_type();
+    return set_compare_func(owner_arg, item_cmp_type(ar, br));
   }
   inline int set_cmp_func(Item_bool_func2 *owner_arg,
 			  Item **a1, Item **a2,
@@ -57,8 +60,11 @@ public:
   inline int set_cmp_func(Item_bool_func2 *owner_arg,
 			  Item **a1, Item **a2)
   {
-    return set_cmp_func(owner_arg, a1, a2, item_cmp_type((*a1)->result_type(),
-							 (*a2)->result_type()));
+    Item_result ar= (*a1)->result_as_longlong() && (*a2)->const_item() ?
+                      INT_RESULT : (*a1)->result_type();
+    Item_result br= (*a2)->result_as_longlong() && (*a1)->const_item() ?
+                      INT_RESULT : (*a2)->result_type();
+    return set_cmp_func(owner_arg, a1, a2, item_cmp_type(ar, br));
   }
   inline int compare() { return (this->*func)(); }
 
diff --git a/sql/item_timefunc.cc b/sql/item_timefunc.cc
index 5fdbd968df1..f7b4c9dd630 100644
--- a/sql/item_timefunc.cc
+++ b/sql/item_timefunc.cc
@@ -2306,6 +2306,20 @@ String *Item_datetime_typecast::val_str(String *str)
 }
 
 
+longlong Item_datetime_typecast::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  TIME ltime;
+  if (get_arg0_date(&ltime,1))
+  {
+    null_value= 1;
+    return 0;
+  }
+
+  return TIME_to_ulonglong_datetime(&ltime);
+}
+
+
 bool Item_time_typecast::get_time(TIME *ltime)
 {
   bool res= get_arg0_time(ltime);
@@ -2320,6 +2334,17 @@ bool Item_time_typecast::get_time(TIME *ltime)
 }
 
 
+longlong Item_time_typecast::val_int()
+{
+  TIME ltime;
+  if (get_time(&ltime))
+  {
+    null_value= 1;
+    return 0;
+  }
+  return ltime.hour * 10000L + ltime.minute * 100 + ltime.second;
+}
+
 String *Item_time_typecast::val_str(String *str)
 {
   DBUG_ASSERT(fixed == 1);
@@ -2359,6 +2384,14 @@ String *Item_date_typecast::val_str(String *str)
   return 0;
 }
 
+longlong Item_date_typecast::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  TIME ltime;
+  if (args[0]->get_date(&ltime, TIME_FUZZY_DATE))
+    return 0;
+  return (longlong) (ltime.year * 10000L + ltime.month * 100 + ltime.day);
+}
 
 /*
   MAKEDATE(a,b) is a date function that creates a date value 
@@ -2395,6 +2428,33 @@ err:
 }
 
 
+longlong Item_func_makedate::val_int()
+{
+  DBUG_ASSERT(fixed == 1);
+  TIME l_time;
+  long daynr=  (long) args[1]->val_int();
+  long yearnr= (long) args[0]->val_int();
+  long days;
+
+  if (args[0]->null_value || args[1]->null_value ||
+      yearnr < 0 || daynr <= 0)
+    goto err;
+
+  days= calc_daynr(yearnr,1,1) + daynr - 1;
+  /* Day number from year 0 to 9999-12-31 */
+  if (days >= 0 && days < MAX_DAY_NUMBER)
+  {
+    null_value=0;
+    get_date_from_daynr(days,&l_time.year,&l_time.month,&l_time.day);
+    return (longlong) (l_time.year * 10000L + l_time.month * 100 + l_time.day);
+  }
+
+err:
+  null_value= 1;
+  return 0;
+}
+
+
 void Item_func_add_time::fix_length_and_dec()
 {
   enum_field_types arg0_field_type;
diff --git a/sql/item_timefunc.h b/sql/item_timefunc.h
index 163b1591e52..95f1dfa75d1 100644
--- a/sql/item_timefunc.h
+++ b/sql/item_timefunc.h
@@ -339,6 +339,7 @@ public:
   {
     return (new Field_date(maybe_null, name, t_arg, &my_charset_bin));
   }  
+  bool result_as_longlong() { return TRUE; }
 };
 
 
@@ -354,6 +355,7 @@ public:
   {
     return (new Field_datetime(maybe_null, name, t_arg, &my_charset_bin));
   }
+  bool result_as_longlong() { return TRUE; }
 };
 
 
@@ -383,6 +385,7 @@ public:
     TIME representation using UTC-SYSTEM or per-thread time zone.
   */
   virtual void store_now_in_TIME(TIME *now_time)=0;
+  bool result_as_longlong() { return TRUE; }
 };
 
 
@@ -588,6 +591,7 @@ public:
   {
     return (new Field_time(maybe_null, name, t_arg, &my_charset_bin));
   }
+  bool result_as_longlong() { return TRUE; }
 };
 
 /*
@@ -715,6 +719,8 @@ public:
     max_length= 10;
     maybe_null= 1;
   }
+  bool result_as_longlong() { return TRUE; }
+  longlong val_int();
 };
 
 
@@ -731,6 +737,8 @@ public:
   {
     return (new Field_time(maybe_null, name, t_arg, &my_charset_bin));
   }
+  bool result_as_longlong() { return TRUE; }
+  longlong val_int();
 };
 
 
@@ -746,6 +754,8 @@ public:
   {
     return (new Field_datetime(maybe_null, name, t_arg, &my_charset_bin));
   }
+  bool result_as_longlong() { return TRUE; }
+  longlong val_int();
 };
 
 class Item_func_makedate :public Item_str_func
@@ -764,6 +774,8 @@ public:
   {
     return (new Field_date(maybe_null, name, t_arg, &my_charset_bin));
   }
+  bool result_as_longlong() { return TRUE; }
+  longlong val_int();
 };
 
 

From 1a9fae81cb5018f8706d49f1032053355ce701c4 Mon Sep 17 00:00:00 2001
From: unknown <sergefp@mysql.com>
Date: Wed, 14 Jun 2006 21:06:02 +0400
Subject: [PATCH 09/11] Better comments in KEY_PART_INFO struct

---
 sql/structs.h | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/sql/structs.h b/sql/structs.h
index 081ada88bf7..2037496635a 100644
--- a/sql/structs.h
+++ b/sql/structs.h
@@ -70,7 +70,13 @@ typedef struct st_key_part_info {	/* Info about a key part */
   Field *field;
   uint	offset;				/* offset in record (from 0) */
   uint	null_offset;			/* Offset to null_bit in record */
-  uint16 length;			/* Length of key_part */
+  uint16 length;                        /* Length of keypart value in bytes */
+  /* 
+    Number of bytes required to store the keypart value. This may be
+    different from the "length" field as it also counts
+     - possible NULL-flag byte (see HA_KEY_NULL_LENGTH)
+     - possible HA_KEY_BLOB_LENGTH bytes needed to store actual value length.
+  */
   uint16 store_length;
   uint16 key_type;
   uint16 fieldnr;			/* Fieldnum in UNIREG */

From e4bfa961ae40a5f55598d2ce183b9fa654b492d6 Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Thu, 15 Jun 2006 16:39:18 +0400
Subject: [PATCH 10/11] item_cmpfunc.h, cast.result:   Post fix for bug#16377

mysql-test/r/cast.result:
  Post fix for bug#16377
sql/item_cmpfunc.h:
  Post fix for bug#16377
---
 mysql-test/r/cast.result |  2 +-
 sql/item_cmpfunc.h       | 15 +++++----------
 2 files changed, 6 insertions(+), 11 deletions(-)

diff --git a/mysql-test/r/cast.result b/mysql-test/r/cast.result
index 2538fbfd61d..68687670e17 100644
--- a/mysql-test/r/cast.result
+++ b/mysql-test/r/cast.result
@@ -192,7 +192,7 @@ cast("2001-1-1" as datetime) = "2001-01-01 00:00:00"
 1
 select cast("1:2:3" as TIME) = "1:02:03";
 cast("1:2:3" as TIME) = "1:02:03"
-1
+0
 select cast(NULL as DATE);
 cast(NULL as DATE)
 NULL
diff --git a/sql/item_cmpfunc.h b/sql/item_cmpfunc.h
index 08d9de6ffd6..68852b5a5f6 100644
--- a/sql/item_cmpfunc.h
+++ b/sql/item_cmpfunc.h
@@ -43,11 +43,8 @@ public:
   int set_compare_func(Item_bool_func2 *owner, Item_result type);
   inline int set_compare_func(Item_bool_func2 *owner_arg)
   {
-    Item_result ar= (*a)->result_as_longlong() && (*b)->const_item() ?
-                      INT_RESULT : (*a)->result_type();
-    Item_result br= (*b)->result_as_longlong() && (*a)->const_item() ?
-                      INT_RESULT : (*b)->result_type();
-    return set_compare_func(owner_arg, item_cmp_type(ar, br));
+    return set_compare_func(owner_arg, item_cmp_type((*a)->result_type(),
+                                                     (*b)->result_type()));
   }
   inline int set_cmp_func(Item_bool_func2 *owner_arg,
 			  Item **a1, Item **a2,
@@ -60,11 +57,9 @@ public:
   inline int set_cmp_func(Item_bool_func2 *owner_arg,
 			  Item **a1, Item **a2)
   {
-    Item_result ar= (*a1)->result_as_longlong() && (*a2)->const_item() ?
-                      INT_RESULT : (*a1)->result_type();
-    Item_result br= (*a2)->result_as_longlong() && (*a1)->const_item() ?
-                      INT_RESULT : (*a2)->result_type();
-    return set_cmp_func(owner_arg, a1, a2, item_cmp_type(ar, br));
+    return set_cmp_func(owner_arg, a1, a2,
+                        item_cmp_type((*a1)->result_type(),
+                                      (*a2)->result_type()));
   }
   inline int compare() { return (this->*func)(); }
 

From ca22a81b1c84ce81e1e9ea2c3ace7be1848027d8 Mon Sep 17 00:00:00 2001
From: unknown <evgen@moonbone.local>
Date: Fri, 16 Jun 2006 23:46:37 +0400
Subject: [PATCH 11/11] item_strfunc.cc:   Fix for bug#16716 for --ps-protocol
 mode. item_cmpfunc.cc:   Fix for a memory allocation/freeing problem in
 agg_cmp_type() after fix for bug#16377. Few language corrections.

sql/item_cmpfunc.cc:
  Fix for a memory allocation/freeing problem in agg_cmp_type(). Few language corrections.
sql/item_strfunc.cc:
  Fix for bug#16716 for --ps-protocol mode.
---
 sql/item_cmpfunc.cc | 32 +++++++++++---------------------
 sql/item_strfunc.cc |  3 ++-
 2 files changed, 13 insertions(+), 22 deletions(-)

diff --git a/sql/item_cmpfunc.cc b/sql/item_cmpfunc.cc
index e92e1d30ca4..126037a24d8 100644
--- a/sql/item_cmpfunc.cc
+++ b/sql/item_cmpfunc.cc
@@ -83,21 +83,21 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
     items will be used for aggregation.
     If there are DATE/TIME fields/functions in the list and no string
     fields/functions in the list then:
-      The INT_RESULT type will be used for aggregation instead of orginal
+      The INT_RESULT type will be used for aggregation instead of original
       result type of any DATE/TIME field/function in the list
       All constant items in the list will be converted to a DATE/TIME using
       found field or result field of found function.
 
     Implementation notes:
-      The code is equvalent to:
-      1. Check the list for presense of a STRING field/function.
+      The code is equivalent to:
+      1. Check the list for presence of a STRING field/function.
          Collect the is_const flag.
       2. Get a Field* object to use for type coercion
       3. Perform type conversion.
       1 and 2 are implemented in 2 loops. The first searches for a DATE/TIME
-      field/function and checks presense of a STRING field/function.
+      field/function and checks presence of a STRING field/function.
       The second loop works only if a DATE/TIME field/function is found.
-      It checks presense of a STRING field/function in the rest of the list.
+      It checks presence of a STRING field/function in the rest of the list.
 
   TODO
     1) The current implementation can produce false comparison results for
@@ -120,8 +120,9 @@ static void agg_result_type(Item_result *type, Item **items, uint nitems)
 static void agg_cmp_type(THD *thd, Item_result *type, Item **items, uint nitems)
 {
   uint i;
-  Item::Type res;
-  char *buff= NULL;
+  Item::Type res= (Item::Type)0;
+  /* Used only for date/time fields, max_length = 19 */
+  char buff[20];
   uchar null_byte;
   Field *field= NULL;
 
@@ -147,28 +148,20 @@ static void agg_cmp_type(THD *thd, Item_result *type, Item **items, uint nitems)
     {
       field= items[i]->tmp_table_field_from_field_type(0);
       if (field)
-        buff= alloc_root(thd->mem_root, field->max_length());
-      if (!buff || !field)
-      {
-        if (field)
-          delete field;
-        if (buff)
-          my_free(buff, MYF(MY_WME));
-        field= 0;
-      }
-      else
         field->move_field(buff, &null_byte, 0);
       break;
     }
   }
   if (field)
   {
-    /* Check the rest of the list for presense of a string field/function. */
+    /* Check the rest of the list for presence of a string field/function. */
     for (i++ ; i < nitems; i++)
     {
       if (!items[i]->const_item() && items[i]->result_type() == STRING_RESULT &&
           !items[i]->result_as_longlong())
       {
+        if (res == Item::FUNC_ITEM)
+          delete field;
         field= 0;
         break;
       }
@@ -205,10 +198,7 @@ static void agg_cmp_type(THD *thd, Item_result *type, Item **items, uint nitems)
   }
 
   if (res == Item::FUNC_ITEM && field)
-  {
     delete field;
-    my_free(buff, MYF(MY_WME));
-  }
 }
 
 static void my_coll_agg_error(DTCollation &c1, DTCollation &c2,
diff --git a/sql/item_strfunc.cc b/sql/item_strfunc.cc
index deb3542f4a5..ee585649f8c 100644
--- a/sql/item_strfunc.cc
+++ b/sql/item_strfunc.cc
@@ -274,7 +274,8 @@ String *Item_func_concat::val_str(String *str)
   if (!(res=args[0]->val_str(str)))
     goto null;
   use_as_buff= &tmp_value;
-  is_const= args[0]->const_item();
+  /* Item_subselect in --ps-protocol mode will state it as a non-const */
+  is_const= args[0]->const_item() || !args[0]->used_tables();
   for (i=1 ; i < arg_count ; i++)
   {
     if (res->length() == 0)