From 6162c4a6eb22b413a477bb6b9b0f08ec9b98a193 Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Tue, 1 Feb 2005 15:08:31 -0800
Subject: [PATCH 01/17] Fix value of YEAR field when set from a non-numeric
 string. (Bug #6067)

mysql-test/t/type_date.test:
  Add new regression test
mysql-test/r/type_date.result:
  Add result
sql/field.cc:
  Set YEAR to 0 when set to a non-numeric string, not 2000,
  and issue a warning.
---
 mysql-test/r/type_date.result |  8 ++++++++
 mysql-test/t/type_date.test   |  7 +++++++
 sql/field.cc                  | 12 ++++++++++--
 3 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/type_date.result b/mysql-test/r/type_date.result
index 71d1b9ad381..3428b5969d9 100644
--- a/mysql-test/r/type_date.result
+++ b/mysql-test/r/type_date.result
@@ -96,3 +96,11 @@ f2
 19781126
 19781126
 DROP TABLE t1, t2, t3;
+CREATE TABLE t1 (y YEAR);
+INSERT INTO t1 VALUES ('abc');
+Warnings:
+Warning	1265	Data truncated for column 'y' at row 1
+SELECT * FROM t1;
+y
+0000
+DROP TABLE t1;
diff --git a/mysql-test/t/type_date.test b/mysql-test/t/type_date.test
index 64420a85189..304ed19b971 100644
--- a/mysql-test/t/type_date.test
+++ b/mysql-test/t/type_date.test
@@ -107,3 +107,10 @@ SELECT * FROM t2;
 SELECT * FROM t3;
 
 DROP TABLE t1, t2, t3;
+
+# Test that setting YEAR to invalid string results in default value, not
+# 2000. (Bug #6067)
+CREATE TABLE t1 (y YEAR);
+INSERT INTO t1 VALUES ('abc');
+SELECT * FROM t1;
+DROP TABLE t1;
diff --git a/sql/field.cc b/sql/field.cc
index 7357bc06f11..a2b749257df 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -3511,9 +3511,17 @@ void Field_time::sql_type(String &res) const
 
 int Field_year::store(const char *from, uint len,CHARSET_INFO *cs)
 {
-  int not_used;				// We can ignore result from str2int
+  int err;
   char *end;
-  long nr= my_strntol(cs, from, len, 10, &end, &not_used);
+  long nr= my_strntol(cs, from, len, 10, &end, &err);
+
+  if (err)
+  {
+    if (table->in_use->count_cuted_fields)
+      set_warning(MYSQL_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
+    *ptr= 0;
+    return 0;
+  }
 
   if (nr < 0 || nr >= 100 && nr <= 1900 || nr > 2155)
   {

From ba51652c2cd753566d768ccdf02f2de92a17a4b2 Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Wed, 2 Feb 2005 15:03:34 -0800
Subject: [PATCH 02/17] Fix 'mysqlcheck --help' to not specify what storage
 engines are supported, rather than give incorrect information. (Bug #8029)

client/mysqlcheck.c:
  Make usage message more general as to what storage engines are supported.
---
 client/mysqlcheck.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/mysqlcheck.c b/client/mysqlcheck.c
index c670b84db44..babf4de0c3d 100644
--- a/client/mysqlcheck.c
+++ b/client/mysqlcheck.c
@@ -195,7 +195,7 @@ static void usage(void)
   puts("and you are welcome to modify and redistribute it under the GPL license.\n");
   puts("This program can be used to CHECK (-c,-m,-C), REPAIR (-r), ANALYZE (-a)");
   puts("or OPTIMIZE (-o) tables. Some of the options (like -e or -q) can be");
-  puts("used at the same time. It works on MyISAM and in some cases on BDB tables.");
+  puts("used at the same time. Not all options are supported by all storage engines.");
   puts("Please consult the MySQL manual for latest information about the");
   puts("above. The options -c,-r,-a and -o are exclusive to each other, which");
   puts("means that the last option will be used, if several was specified.\n");

From 567055363e69843feb8215c8cef0e832ceb472cf Mon Sep 17 00:00:00 2001
From: unknown <acurtis@pcgem.rdg.cyberkinetica.com>
Date: Thu, 3 Feb 2005 18:26:59 +0000
Subject: [PATCH 03/17] Bug#7310   Fix test for classic builds

mysql-test/t/multi_update.test:
  Bug#7310
    Ignore warnings for Bug#5837 test
---
 mysql-test/t/multi_update.test | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/mysql-test/t/multi_update.test b/mysql-test/t/multi_update.test
index 2d6770f77ed..2fc4ebcb275 100644
--- a/mysql-test/t/multi_update.test
+++ b/mysql-test/t/multi_update.test
@@ -340,8 +340,10 @@ drop table t1, t2;
 
 # Test for BUG#5837 - delete with outer join and const tables
 drop table if exists t2, t1;
+--disable_warnings
 create table t1(aclid bigint not null primary key, status tinyint(1) not null ) type = innodb;
 create table t2(refid bigint not null primary key, aclid bigint, index idx_acl(aclid) )type = innodb;
+--enable_warnings
 insert into t2 values(1,null);
 delete t2, t1 from t2 as a left join t1 as b on (a.aclid=b.aclid) where a.refid='1';
 drop table t1, t2;

From a3efbf47c80bf6896c6a9fceecd761b757f76971 Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Thu, 3 Feb 2005 14:21:16 -0800
Subject: [PATCH 04/17] Copy *.result.es files for binary distribution so
 embedded tests can be run

scripts/make_binary_distribution.sh:
  Make sure to copy result.es files
---
 scripts/make_binary_distribution.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/make_binary_distribution.sh b/scripts/make_binary_distribution.sh
index 33d4794e4f7..910aa38c33f 100644
--- a/scripts/make_binary_distribution.sh
+++ b/scripts/make_binary_distribution.sh
@@ -220,7 +220,7 @@ $CP mysql-test/include/*.inc $BASE/mysql-test/include
 $CP mysql-test/std_data/*.dat mysql-test/std_data/*.*001 $BASE/mysql-test/std_data
 $CP mysql-test/std_data/des_key_file $BASE/mysql-test/std_data
 $CP mysql-test/t/*test mysql-test/t/*.opt mysql-test/t/*.slave-mi mysql-test/t/*.sh $BASE/mysql-test/t
-$CP mysql-test/r/*result mysql-test/r/*.require $BASE/mysql-test/r
+$CP mysql-test/r/*result mysql-test/r/*result.es mysql-test/r/*.require $BASE/mysql-test/r
 
 if [ $BASE_SYSTEM != "netware" ] ; then
   chmod a+x $BASE/bin/*

From 66eb71f3fc13fefaa6d72532b521a28c09138aa3 Mon Sep 17 00:00:00 2001
From: unknown <gluh@gluh.mysql.r18.ru>
Date: Fri, 4 Feb 2005 15:31:36 +0300
Subject: [PATCH 05/17] A fix: bug#6931: Date Type column problem when using
 UNION-Table        bug#7833:  Wrong datatype of aggregate column is returned

mysql-test/r/func_group.result:
  Test case for bug 7833:  Wrong datatype of aggregate column is returned
mysql-test/r/union.result:
  Test case for bug 6931: Date Type column problem when using UNION-Table.
mysql-test/t/func_group.test:
  Test case for bug 7833:  Wrong datatype of aggregate column is returned
mysql-test/t/union.test:
  Test case for bug 6931: Date Type column problem when using UNION-Table.
---
 mysql-test/r/func_group.result | 12 +++++++
 mysql-test/r/union.result      | 36 +++++++++++++++++++
 mysql-test/t/func_group.test   | 14 ++++++++
 mysql-test/t/union.test        | 35 ++++++++++++++++++
 sql/field.cc                   | 35 ++++++++++++++++++
 sql/field.h                    |  1 +
 sql/item.cc                    | 65 +++++++++++++++++++++++++++-------
 sql/item.h                     |  4 +--
 sql/sql_union.cc               | 14 ++++++--
 9 files changed, 200 insertions(+), 16 deletions(-)

diff --git a/mysql-test/r/func_group.result b/mysql-test/r/func_group.result
index 4bb79a1cb41..fa645700875 100644
--- a/mysql-test/r/func_group.result
+++ b/mysql-test/r/func_group.result
@@ -733,3 +733,15 @@ one	2
 two	2
 three	1
 drop table t1;
+create table t1(f1 datetime);
+insert into t1 values (now());
+create table t2 select f2 from (select max(now()) f2 from t1) a;
+show columns from t2;
+Field	Type	Null	Key	Default	Extra
+f2	datetime			0000-00-00 00:00:00	
+drop table t2;
+create table t2 select f2 from (select now() f2 from t1) a;
+show columns from t2;
+Field	Type	Null	Key	Default	Extra
+f2	datetime			0000-00-00 00:00:00	
+drop table t2, t1;
diff --git a/mysql-test/r/union.result b/mysql-test/r/union.result
index f07bdad9021..115ef6a47f9 100644
--- a/mysql-test/r/union.result
+++ b/mysql-test/r/union.result
@@ -1137,3 +1137,39 @@ t1	CREATE TABLE `t1` (
 ) ENGINE=MyISAM DEFAULT CHARSET=latin1
 drop table t1;
 drop table t2;
+create table t1(a1 int, f1 char(10));
+create table t2
+select f2,a1 from (select a1, CAST('2004-12-31' AS DATE) f2 from t1) a
+union
+select f2,a1 from (select a1, CAST('2004-12-31' AS DATE) f2 from t1) a
+order by f2, a1;
+show columns from t2;
+Field	Type	Null	Key	Default	Extra
+f2	date	YES		NULL	
+a1	int(11)	YES		NULL	
+drop table t1, t2;
+create table t1 (f1 int);
+create table t2 (f1 int, f2 int ,f3 date);
+create table t3 (f1 int, f2 char(10));
+create table t4
+(
+select t2.f3 as sdate
+from t1
+left outer join t2 on (t1.f1 = t2.f1)
+inner join t3 on (t2.f2 = t3.f1)
+order by t1.f1, t3.f1, t2.f3
+)
+union
+(
+select cast('2004-12-31' as date) as sdate
+from t1
+left outer join t2 on (t1.f1 = t2.f1)
+inner join t3 on (t2.f2 = t3.f1)
+group by t1.f1
+order by t1.f1, t3.f1, t2.f3
+)
+order by sdate;
+show columns from t4;
+Field	Type	Null	Key	Default	Extra
+sdate	date	YES		NULL	
+drop table t1, t2, t3, t4;
diff --git a/mysql-test/t/func_group.test b/mysql-test/t/func_group.test
index 79d6112e6de..465611a5ebb 100644
--- a/mysql-test/t/func_group.test
+++ b/mysql-test/t/func_group.test
@@ -473,3 +473,17 @@ INSERT INTO t1 VALUES
 
 select val, count(*) from t1 group by val;
 drop table t1;
+
+
+#
+# Bug 7833:  Wrong datatype of aggregate column is returned
+#
+
+create table t1(f1 datetime);
+insert into t1 values (now());
+create table t2 select f2 from (select max(now()) f2 from t1) a;
+show columns from t2;
+drop table t2;
+create table t2 select f2 from (select now() f2 from t1) a;
+show columns from t2;
+drop table t2, t1;
diff --git a/mysql-test/t/union.test b/mysql-test/t/union.test
index 8682808f3f3..90b2197603b 100644
--- a/mysql-test/t/union.test
+++ b/mysql-test/t/union.test
@@ -664,3 +664,38 @@ show create table t1;
 drop table t1;
 drop table t2;
 
+#
+# Bug 6931: Date Type column problem when using UNION-Table.
+#
+create table t1(a1 int, f1 char(10));
+create table t2
+select f2,a1 from (select a1, CAST('2004-12-31' AS DATE) f2 from t1) a
+union
+select f2,a1 from (select a1, CAST('2004-12-31' AS DATE) f2 from t1) a
+order by f2, a1;
+show columns from t2;
+drop table t1, t2;
+
+create table t1 (f1 int);
+create table t2 (f1 int, f2 int ,f3 date);
+create table t3 (f1 int, f2 char(10));
+create table t4
+(
+  select t2.f3 as sdate
+  from t1
+  left outer join t2 on (t1.f1 = t2.f1)
+  inner join t3 on (t2.f2 = t3.f1)
+  order by t1.f1, t3.f1, t2.f3
+)
+union
+(
+  select cast('2004-12-31' as date) as sdate
+  from t1
+  left outer join t2 on (t1.f1 = t2.f1)
+  inner join t3 on (t2.f2 = t3.f1)
+  group by t1.f1
+  order by t1.f1, t3.f1, t2.f3
+)
+order by sdate;
+show columns from t4;
+drop table t1, t2, t3, t4;
diff --git a/sql/field.cc b/sql/field.cc
index 7357bc06f11..9965cb792be 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -245,6 +245,7 @@ static Field::field_cast_enum field_cast_date[]=
  Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
 static Field::field_cast_enum field_cast_newdate[]=
 {Field::FIELD_CAST_NEWDATE,
+ Field::FIELD_CAST_DATE,
  Field::FIELD_CAST_DATETIME,
  Field::FIELD_CAST_STRING, Field::FIELD_CAST_VARSTRING,
  Field::FIELD_CAST_BLOB, Field::FIELD_CAST_STOP};
@@ -6024,6 +6025,40 @@ Field *make_field(char *ptr, uint32 field_length,
 }
 
 
+/*
+  Check if field_type is appropriate field type
+  to create field for tmp table using
+  item->tmp_table_field() method
+
+  SYNOPSIS
+    field_types_to_be_kept()
+    field_type     - field type
+
+  NOTE
+    it is used in function get_holder_example_field()
+    from item.cc
+
+  RETURN
+    1 - can use item->tmp_table_field() method
+    0 - can not use item->tmp_table_field() method
+
+*/
+
+bool field_types_to_be_kept(enum_field_types field_type)
+{
+  switch (field_type)
+  {
+    case FIELD_TYPE_DATE:
+    case FIELD_TYPE_NEWDATE:
+    case FIELD_TYPE_TIME:
+    case FIELD_TYPE_DATETIME:
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+
 /* Create a field suitable for create of table */
 
 create_field::create_field(Field *old_field,Field *orig_field)
diff --git a/sql/field.h b/sql/field.h
index 27a01a69273..fd0f2f9c2f1 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -1265,6 +1265,7 @@ int set_field_to_null(Field *field);
 int set_field_to_null_with_conversions(Field *field, bool no_conversions);
 bool test_if_int(const char *str, int length, const char *int_end,
 		 CHARSET_INFO *cs);
+bool field_types_to_be_kept(enum_field_types field_type);
 
 /*
   The following are for the interface with the .frm file
diff --git a/sql/item.cc b/sql/item.cc
index ab29c147dfb..d61d628e8fa 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -2639,7 +2639,53 @@ void Item_cache_row::bring_value()
 }
 
 
-Item_type_holder::Item_type_holder(THD *thd, Item *item)
+/*
+  Returns field for temporary table dependind on item type
+
+  SYNOPSIS
+    get_holder_example_field()
+    thd            - thread handler
+    item           - pointer to item
+    table          - empty table object
+
+  NOTE
+    It is possible to return field for Item_func 
+    items only if field type of this item is 
+    date or time or datetime type.
+    also see function field_types_to_be_kept() from
+    field.cc
+
+  RETURN
+    # - field
+    0 - no field
+*/
+
+Field *get_holder_example_field(THD *thd, Item *item, TABLE *table)
+{
+  DBUG_ASSERT(table);
+
+  Item_func *tmp_item= 0;
+  if (item->type() == Item::FIELD_ITEM)
+    return (((Item_field*) item)->field);
+  if (item->type() == Item::FUNC_ITEM)
+    tmp_item= (Item_func *) item;
+  else if (item->type() == Item::SUM_FUNC_ITEM)
+  {
+    Item_sum *item_sum= (Item_sum *) item;
+    if (item_sum->keep_field_type())
+    {
+      if (item_sum->args[0]->type() == Item::FIELD_ITEM)
+        return (((Item_field*) item_sum->args[0])->field);
+      if (item_sum->args[0]->type() == Item::FUNC_ITEM)
+        tmp_item= (Item_func *) item_sum->args[0];
+    }
+  }
+  return (tmp_item && field_types_to_be_kept(tmp_item->field_type()) ?
+          tmp_item->tmp_table_field(table) : 0);
+}
+
+
+Item_type_holder::Item_type_holder(THD *thd, Item *item, TABLE *table)
   :Item(thd, item), item_type(item->result_type()),
    orig_type(item_type)
 {
@@ -2649,10 +2695,7 @@ Item_type_holder::Item_type_holder(THD *thd, Item *item)
     It is safe assign pointer on field, because it will be used just after
     all JOIN::prepare calls and before any SELECT execution
   */
-  if (item->type() == Item::FIELD_ITEM)
-    field_example= ((Item_field*) item)->field;
-  else
-    field_example= 0;
+  field_example= get_holder_example_field(thd, item, table);
   max_length= real_length(item);
   maybe_null= item->maybe_null;
   collation.set(item->collation);
@@ -2692,25 +2735,23 @@ inline bool is_attr_compatible(Item *from, Item *to)
           (to->maybe_null || !from->maybe_null) &&
           (to->result_type() != STRING_RESULT ||
            from->result_type() != STRING_RESULT ||
-           my_charset_same(from->collation.collation,
-                           to->collation.collation)));
+          (from->collation.collation == to->collation.collation)));
 }
 
 
-bool Item_type_holder::join_types(THD *thd, Item *item)
+bool Item_type_holder::join_types(THD *thd, Item *item, TABLE *table)
 {
   uint32 new_length= real_length(item);
   bool use_new_field= 0, use_expression_type= 0;
   Item_result new_result_type= type_convertor[item_type][item->result_type()];
-  bool item_is_a_field= item->type() == Item::FIELD_ITEM;
-
+  Field *field= get_holder_example_field(thd, item, table);
+  bool item_is_a_field= field;
   /*
     Check if both items point to fields: in this case we
     can adjust column types of result table in the union smartly.
   */
   if (field_example && item_is_a_field)
   {
-    Field *field= ((Item_field *)item)->field;
     /* Can 'field_example' field store data of the column? */
     if ((use_new_field=
          (!field->field_cast_compatible(field_example->field_cast_type()) ||
@@ -2751,7 +2792,7 @@ bool Item_type_holder::join_types(THD *thd, Item *item)
         It is safe to assign a pointer to field here, because it will be used
         before any table is closed.
       */
-      field_example= ((Item_field*) item)->field;
+      field_example= field;
     }
 
     old_cs= collation.collation->name;
diff --git a/sql/item.h b/sql/item.h
index 237a8f7efac..e0de7452eec 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -1321,14 +1321,14 @@ protected:
   Item_result orig_type;
   Field *field_example;
 public:
-  Item_type_holder(THD*, Item*);
+  Item_type_holder(THD*, Item*, TABLE *);
 
   Item_result result_type () const { return item_type; }
   enum Type type() const { return TYPE_HOLDER; }
   double val();
   longlong val_int();
   String *val_str(String*);
-  bool join_types(THD *thd, Item *);
+  bool join_types(THD *thd, Item *, TABLE *);
   Field *example() { return field_example; }
   static uint32 real_length(Item *item);
   void cleanup()
diff --git a/sql/sql_union.cc b/sql/sql_union.cc
index 027a21db7ac..882316d57d7 100644
--- a/sql/sql_union.cc
+++ b/sql/sql_union.cc
@@ -148,6 +148,7 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
   SELECT_LEX *sl, *first_select;
   select_result *tmp_result;
   bool is_union;
+  TABLE *empty_table= 0;
   DBUG_ENTER("st_select_lex_unit::prepare");
 
   describe= test(additional_options & SELECT_DESCRIBE);
@@ -239,13 +240,21 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
       goto err;
     if (sl == first_select)
     {
+      /*
+        We need to create an empty table object. It is used
+        to create tmp_table fields in Item_type_holder.
+        The main reason of this is that we can't create
+        field object without table.
+      */
+      DBUG_ASSERT(!empty_table);
+      empty_table= (TABLE*) thd->calloc(sizeof(TABLE));
       types.empty();
       List_iterator_fast<Item> it(sl->item_list);
       Item *item_tmp;
       while ((item_tmp= it++))
       {
 	/* Error's in 'new' will be detected after loop */
-	types.push_back(new Item_type_holder(thd_arg, item_tmp));
+	types.push_back(new Item_type_holder(thd_arg, item_tmp, empty_table));
       }
 
       if (thd_arg->is_fatal_error)
@@ -264,7 +273,8 @@ int st_select_lex_unit::prepare(THD *thd_arg, select_result *sel_result,
       Item *type, *item_tmp;
       while ((type= tp++, item_tmp= it++))
       {
-	if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp))
+        if (((Item_type_holder*)type)->join_types(thd_arg, item_tmp,
+                                                  empty_table))
 	  DBUG_RETURN(-1);
       }
     }

From 8c750c466b0109723233e93aea85a39673409b40 Mon Sep 17 00:00:00 2001
From: unknown <serg@serg.mylan>
Date: Fri, 4 Feb 2005 15:24:06 +0100
Subject: [PATCH 06/17] indexless boolean fulltext search was depending on
 default_charset_info - Bug#8159 ftbw->off wasn't cleared on reinit - Bug#8234

include/ft_global.h:
  get rid of default_charset_info in indexless fulltext searches
myisam/ft_boolean_search.c:
  get rid of default_charset_info in indexless fulltext searches
  clear ftbw->off on reinits
myisam/ft_static.c:
  get rid of default_charset_info in indexless fulltext searches
myisam/ftdefs.h:
  get rid of default_charset_info in indexless fulltext searches
sql/ha_myisam.h:
  get rid of default_charset_info in indexless fulltext searches
sql/handler.h:
  get rid of default_charset_info in indexless fulltext searches
sql/item_func.cc:
  get rid of default_charset_info in indexless fulltext searches
---
 include/ft_global.h        | 2 +-
 myisam/ft_boolean_search.c | 7 ++++---
 myisam/ft_static.c         | 5 +++--
 myisam/ftdefs.h            | 2 +-
 sql/ha_myisam.h            | 8 ++++++--
 sql/handler.h              | 3 +--
 sql/item_func.cc           | 8 +++-----
 7 files changed, 19 insertions(+), 16 deletions(-)

diff --git a/include/ft_global.h b/include/ft_global.h
index 94f6ad9ef51..c3f60d13a7a 100644
--- a/include/ft_global.h
+++ b/include/ft_global.h
@@ -62,7 +62,7 @@ void ft_free_stopwords(void);
 #define FT_SORTED 2
 #define FT_EXPAND 4   /* query expansion */
 
-FT_INFO *ft_init_search(uint,void *, uint, byte *, uint, byte *);
+FT_INFO *ft_init_search(uint,void *, uint, byte *, uint,CHARSET_INFO *, byte *);
 my_bool ft_boolean_check_syntax_string(const byte *);
 
 #ifdef  __cplusplus
diff --git a/myisam/ft_boolean_search.c b/myisam/ft_boolean_search.c
index aab3854dd34..4253b5ff96f 100644
--- a/myisam/ft_boolean_search.c
+++ b/myisam/ft_boolean_search.c
@@ -365,6 +365,7 @@ static void _ftb_init_index_search(FT_INFO *ftb)
         reset_tree(& ftb->no_dupes);
     }
 
+    ftbw->off=0; /* in case of reinit */
     if (_ft2_search(ftb, ftbw, 1))
       return;
   }
@@ -373,7 +374,7 @@ static void _ftb_init_index_search(FT_INFO *ftb)
 
 
 FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, byte *query,
-                                 uint query_len)
+                                 uint query_len, CHARSET_INFO *cs)
 {
   FTB       *ftb;
   FTB_EXPR  *ftbe;
@@ -385,8 +386,8 @@ FT_INFO * ft_init_boolean_search(MI_INFO *info, uint keynr, byte *query,
   ftb->state=UNINITIALIZED;
   ftb->info=info;
   ftb->keynr=keynr;
-  ftb->charset= ((keynr==NO_SUCH_KEY) ?
-           default_charset_info : info->s->keyinfo[keynr].seg->charset);
+  ftb->charset=cs;
+  DBUG_ASSERT(keynr==NO_SUCH_KEY || cs == info->s->keyinfo[keynr].seg->charset);
   ftb->with_scan=0;
   ftb->lastpos=HA_OFFSET_ERROR;
   bzero(& ftb->no_dupes, sizeof(TREE));
diff --git a/myisam/ft_static.c b/myisam/ft_static.c
index 7168406d027..994a94d0c49 100644
--- a/myisam/ft_static.c
+++ b/myisam/ft_static.c
@@ -55,11 +55,12 @@ const struct _ft_vft _ft_vft_boolean = {
 
 
 FT_INFO *ft_init_search(uint flags, void *info, uint keynr,
-                        byte *query, uint query_len, byte *record)
+                        byte *query, uint query_len, CHARSET_INFO *cs,
+                        byte *record)
 {
   FT_INFO *res;
   if (flags & FT_BOOL)
-    res= ft_init_boolean_search((MI_INFO *)info, keynr, query, query_len);
+    res= ft_init_boolean_search((MI_INFO *)info, keynr, query, query_len,cs);
   else
     res= ft_init_nlq_search((MI_INFO *)info, keynr, query, query_len, flags,
 			    record);
diff --git a/myisam/ftdefs.h b/myisam/ftdefs.h
index e7a0829e140..ddb9fbfead2 100644
--- a/myisam/ftdefs.h
+++ b/myisam/ftdefs.h
@@ -131,7 +131,7 @@ FT_WORD * _mi_ft_parserecord(MI_INFO *, uint, const byte *);
 uint _mi_ft_parse(TREE *, MI_INFO *, uint, const byte *, my_bool);
 
 FT_INFO *ft_init_nlq_search(MI_INFO *, uint, byte *, uint, uint, byte *);
-FT_INFO *ft_init_boolean_search(MI_INFO *, uint, byte *, uint);
+FT_INFO *ft_init_boolean_search(MI_INFO *, uint, byte *, uint, CHARSET_INFO *);
 
 extern const struct _ft_vft _ft_vft_nlq;
 int ft_nlq_read_next(FT_INFO *, char *);
diff --git a/sql/ha_myisam.h b/sql/ha_myisam.h
index 972d6b18e19..1e6cf2f4ada 100644
--- a/sql/ha_myisam.h
+++ b/sql/ha_myisam.h
@@ -88,8 +88,12 @@ class ha_myisam: public handler
     ft_handler->please->reinit_search(ft_handler);
     return 0;
   }
-  FT_INFO *ft_init_ext(uint flags, uint inx,const byte *key, uint keylen)
-  { return ft_init_search(flags,file,inx,(byte*) key,keylen, table->record[0]); }
+  FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
+  {
+    return ft_init_search(flags,file,inx,
+                          (byte *)key->ptr(), key->length(), key->charset(),
+                          table->record[0]);
+  }
   int ft_read(byte *buf);
   int rnd_init(bool scan);
   int rnd_next(byte *buf);
diff --git a/sql/handler.h b/sql/handler.h
index 245defe61e0..0426312f404 100644
--- a/sql/handler.h
+++ b/sql/handler.h
@@ -373,8 +373,7 @@ public:
   int compare_key(key_range *range);
   virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
   void ft_end() { ft_handler=NULL; }
-  virtual FT_INFO *ft_init_ext(uint flags,uint inx,const byte *key,
-                               uint keylen)
+  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
     { return NULL; }
   virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
   virtual int rnd_next(byte *buf)=0;
diff --git a/sql/item_func.cc b/sql/item_func.cc
index bff49541252..85cd1c693b7 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -3047,9 +3047,7 @@ void Item_func_match::init_search(bool no_order)
 
   if (join_key && !no_order)
     flags|=FT_SORTED;
-  ft_handler=table->file->ft_init_ext(flags, key,
-				      (byte*) ft_tmp->ptr(),
-				      ft_tmp->length());
+  ft_handler=table->file->ft_init_ext(flags, key, ft_tmp);
 
   if (join_key)
     table->file->ft_handler=ft_handler;
@@ -3091,12 +3089,12 @@ bool Item_func_match::fix_fields(THD *thd, TABLE_LIST *tlist, Item **ref)
   }
   /*
     Check that all columns come from the same table.
-    We've already checked that columns in MATCH are fields so 
+    We've already checked that columns in MATCH are fields so
     PARAM_TABLE_BIT can only appear from AGAINST argument.
   */
   if ((used_tables_cache & ~PARAM_TABLE_BIT) != item->used_tables())
     key=NO_SUCH_KEY;
-  
+
   if (key == NO_SUCH_KEY && !(flags & FT_BOOL))
   {
     my_error(ER_WRONG_ARGUMENTS,MYF(0),"MATCH");

From 8ed40c4b09bb4c56f17a1432fc9024a5dfc4e04a Mon Sep 17 00:00:00 2001
From: unknown <hf@deer.(none)>
Date: Fri, 4 Feb 2005 19:12:15 +0400
Subject: [PATCH 07/17] Embedded version of test fixed

mysql-test/r/insert_select.result.es:
  Test.es fixed
---
 mysql-test/r/insert_select.result.es | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/mysql-test/r/insert_select.result.es b/mysql-test/r/insert_select.result.es
index 9e11402733d..9cac6d31b8f 100644
--- a/mysql-test/r/insert_select.result.es
+++ b/mysql-test/r/insert_select.result.es
@@ -633,3 +633,15 @@ No	Field	Count
 0	1	100
 0	2	100
 drop table t1, t2;
+CREATE TABLE t1 (
+ID           int(11) NOT NULL auto_increment,
+NO           int(11) NOT NULL default '0',
+SEQ          int(11) NOT NULL default '0',
+PRIMARY KEY  (ID),
+KEY t1$NO    (SEQ,NO)
+) ENGINE=MyISAM;
+INSERT INTO t1 (SEQ, NO) SELECT "1" AS SEQ, IF(MAX(NO) IS NULL, 0, MAX(NO)) + 1 AS NO FROM t1 WHERE (SEQ = 1);
+select SQL_BUFFER_RESULT * from t1 WHERE (SEQ = 1);
+ID	NO	SEQ
+1	1	1
+drop table t1;

From 12c522515f505854850cf3e64721499492da4d53 Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Fri, 4 Feb 2005 12:01:30 -0800
Subject: [PATCH 08/17] Merge

---
 sql/field.h | 240 +++++++++++++++++++++++++++++++++-------------------
 1 file changed, 154 insertions(+), 86 deletions(-)

diff --git a/sql/field.h b/sql/field.h
index fd0f2f9c2f1..756fa713707 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -37,11 +37,7 @@ class Field
   void operator=(Field &);
 public:
   static void *operator new(size_t size) {return (void*) sql_alloc((uint) size); }
-  static void operator delete(void *ptr_arg, size_t size) {
-#ifdef SAFEMALLOC
-    bfill(ptr_arg, size, 0x8F);
-#endif
-  }
+  static void operator delete(void *ptr_arg, size_t size) { TRASH(ptr_arg, size); }
 
   char		*ptr;			// Position to field in record
   uchar		*null_ptr;		// Byte where null_bit is
@@ -51,7 +47,7 @@ public:
   */
   struct st_table *table;		// Pointer for table
   struct st_table *orig_table;		// Pointer to original table
-  const char	*table_name,*field_name;
+  const char	**table_name, *field_name;
   LEX_STRING	comment;
   ulong		query_id;		// For quick test of used fields
   /* Field is part of the following keys */
@@ -84,7 +80,7 @@ public:
     FIELD_CAST_TIMESTAMP, FIELD_CAST_YEAR, FIELD_CAST_DATE, FIELD_CAST_NEWDATE,
     FIELD_CAST_TIME, FIELD_CAST_DATETIME,
     FIELD_CAST_STRING, FIELD_CAST_VARSTRING, FIELD_CAST_BLOB,
-    FIELD_CAST_GEOM, FIELD_CAST_ENUM, FIELD_CAST_SET
+    FIELD_CAST_GEOM, FIELD_CAST_ENUM, FIELD_CAST_SET, FIELD_CAST_BIT
   };
 
   utype		unireg_check;
@@ -100,7 +96,7 @@ public:
   virtual int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
   virtual int  store(double nr)=0;
   virtual int  store(longlong nr)=0;
-  virtual void store_time(TIME *ltime,timestamp_type t_type);
+  virtual int store_time(TIME *ltime, timestamp_type t_type);
   virtual double val_real(void)=0;
   virtual longlong val_int(void)=0;
   inline String *val_str(String *str) { return val_str(str, str); }
@@ -117,16 +113,22 @@ public:
      This trickery is used to decrease a number of malloc calls.
   */
   virtual String *val_str(String*,String *)=0;
+  String *val_int_as_str(String *val_buffer, my_bool unsigned_flag);
   virtual Item_result result_type () const=0;
   virtual Item_result cmp_type () const { return result_type(); }
-  bool eq(Field *field) { return ptr == field->ptr && null_ptr == field->null_ptr; }
+  bool eq(Field *field)
+  {
+    return (ptr == field->ptr && null_ptr == field->null_ptr &&
+            null_bit == field->null_bit);
+  }
   virtual bool eq_def(Field *field);
   virtual uint32 pack_length() const { return (uint32) field_length; }
+  virtual uint32 pack_length_in_rec() const { return pack_length(); }
   virtual void reset(void) { bzero(ptr,pack_length()); }
   virtual void reset_fields() {}
   virtual void set_default()
   {
-    my_ptrdiff_t offset = (my_ptrdiff_t) (table->default_values -
+    my_ptrdiff_t offset = (my_ptrdiff_t) (table->s->default_values -
 					  table->record[0]);
     memcpy(ptr, ptr + offset, pack_length());
     if (null_ptr)
@@ -143,10 +145,9 @@ public:
   virtual int cmp(const char *,const char *)=0;
   virtual int cmp_binary(const char *a,const char *b, uint32 max_length=~0L)
   { return memcmp(a,b,pack_length()); }
-  virtual int cmp_offset(uint row_offset)
-  { return memcmp(ptr,ptr+row_offset,pack_length()); }
-  virtual int cmp_binary_offset(uint row_offset)
-  { return memcmp(ptr,ptr+row_offset,pack_length()); }
+  int cmp_offset(uint row_offset) { return cmp(ptr,ptr+row_offset); }
+  int cmp_binary_offset(uint row_offset)
+  { return cmp_binary(ptr, ptr+row_offset); };
   virtual int key_cmp(const byte *a,const byte *b)
   { return cmp((char*) a,(char*) b); }
   virtual int key_cmp(const byte *str, uint length)
@@ -176,7 +177,7 @@ public:
     { if (null_ptr) null_ptr[row_offset]&= (uchar) ~null_bit; }
   inline bool maybe_null(void) { return null_ptr != 0 || table->maybe_null; }
   inline bool real_maybe_null(void) { return null_ptr != 0; }
-  virtual void make_field(Send_field *)=0;
+  virtual void make_field(Send_field *);
   virtual void sort_string(char *buff,uint length)=0;
   virtual bool optimize_range(uint idx, uint part);
   /*
@@ -188,28 +189,11 @@ public:
   */
   virtual bool can_be_compared_as_longlong() const { return FALSE; }
   virtual void free() {}
-  Field *new_field(MEM_ROOT *root, struct st_table *new_table)
-  {
-    Field *tmp= (Field*) memdup_root(root,(char*) this,size_of());
-    if (tmp)
-    {
-      if (tmp->table->maybe_null)
-	tmp->flags&= ~NOT_NULL_FLAG;
-      tmp->table= new_table;
-      tmp->key_start.init(0);
-      tmp->part_of_key.init(0);
-      tmp->part_of_sortkey.init(0);
-      tmp->unireg_check=Field::NONE;
-      tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG |
-		    ZEROFILL_FLAG | BINARY_FLAG | ENUM_FLAG | SET_FLAG);
-#ifdef PROBABLY_WRONG
-      tmp->table_name= new_table->table_name;
-#endif
-      tmp->reset_fields();
-    }
-    return tmp;
-  }
-  inline void move_field(char *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
+  virtual Field *new_field(MEM_ROOT *root, struct st_table *new_table);
+  virtual Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
+                               char *new_ptr, uchar *new_null_ptr,
+                               uint new_null_bit);
+  virtual void move_field(char *ptr_arg,uchar *null_ptr_arg,uchar null_bit_arg)
   {
     ptr=ptr_arg; null_ptr=null_ptr_arg; null_bit=null_bit_arg;
   }
@@ -224,11 +208,10 @@ public:
     { memcpy(buff,ptr,length); }
   inline void set_image(char *buff,uint length, CHARSET_INFO *cs)
     { memcpy(ptr,buff,length); }
-  virtual void get_key_image(char *buff,uint length, CHARSET_INFO *cs,
-			     imagetype type)
-    { get_image(buff,length,cs); }
-  virtual void set_key_image(char *buff,uint length, CHARSET_INFO *cs)
-    { set_image(buff,length,cs); }
+  virtual void get_key_image(char *buff, uint length, imagetype type)
+    { get_image(buff,length, &my_charset_bin); }
+  virtual void set_key_image(char *buff,uint length)
+    { set_image(buff,length, &my_charset_bin); }
   inline longlong val_int_offset(uint row_offset)
     {
       ptr+=row_offset;
@@ -236,6 +219,17 @@ public:
       ptr-=row_offset;
       return tmp;
     }
+
+  inline String *val_str(String *str, char *new_ptr)
+  {
+    char *old_ptr= ptr;
+    ptr= new_ptr;
+    val_str(str);
+    ptr= old_ptr;
+    return str;
+  }
+  bool quote_data(String *unquoted_string);
+  bool needs_quotes(void);
   virtual bool send_binary(Protocol *protocol);
   virtual char *pack(char* to, const char *from, uint max_length=~(uint) 0)
   {
@@ -267,9 +261,11 @@ public:
   virtual uint max_packed_col_length(uint max_length)
   { return max_length;}
 
-  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg)
+  virtual int pack_cmp(const char *a,const char *b, uint key_length_arg,
+                       my_bool insert_or_update)
   { return cmp(a,b); }
-  virtual int pack_cmp(const char *b, uint key_length_arg)
+  virtual int pack_cmp(const char *b, uint key_length_arg,
+                       my_bool insert_or_update)
   { return cmp(ptr,b); }
   uint offset();			// Should be inline ...
   void copy_from_tmp(int offset);
@@ -281,6 +277,8 @@ public:
   virtual void set_charset(CHARSET_INFO *charset) { }
   bool set_warning(const unsigned int level, const unsigned int code, 
                    int cuted_increment);
+  bool check_int(const char *str, int length, const char *int_end,
+                 CHARSET_INFO *cs);
   void set_datetime_warning(const uint level, const uint code, 
                             const char *str, uint str_len,
                             timestamp_type ts_type, int cuted_increment);
@@ -360,7 +358,6 @@ public:
   int  store(double nr);
   int  store(longlong nr)=0;
   int  store(const char *to,uint length,CHARSET_INFO *cs)=0;
-  void make_field(Send_field *);
   uint size_of() const { return sizeof(*this); }
   CHARSET_INFO *charset(void) const { return field_charset; }
   void set_charset(CHARSET_INFO *charset) { field_charset=charset; }
@@ -719,7 +716,7 @@ public:
     if ((*null_value= is_null()))
       return 0;
 #ifdef WORDS_BIGENDIAN
-    if (table->db_low_byte_first)
+    if (table->s->db_low_byte_first)
       return sint4korr(ptr);
 #endif
     long tmp;
@@ -803,7 +800,7 @@ public:
   int  store(const char *to,uint length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr);
-  void store_time(TIME *ltime,timestamp_type type);
+  int store_time(TIME *ltime, timestamp_type type);
   void reset(void) { ptr[0]=ptr[1]=ptr[2]=0; }
   double val_real(void);
   longlong val_int(void);
@@ -836,6 +833,7 @@ public:
   enum_field_types type() const { return FIELD_TYPE_TIME;}
   enum ha_base_keytype key_type() const { return HA_KEYTYPE_INT24; }
   enum Item_result cmp_type () const { return INT_RESULT; }
+  int store_time(TIME *ltime, timestamp_type type);
   int  store(const char *to,uint length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr);
@@ -876,7 +874,7 @@ public:
   int  store(const char *to,uint length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr);
-  void store_time(TIME *ltime,timestamp_type type);
+  int store_time(TIME *ltime, timestamp_type type);
   void reset(void) { ptr[0]=ptr[1]=ptr[2]=ptr[3]=ptr[4]=ptr[5]=ptr[6]=ptr[7]=0; }
   double val_real(void);
   longlong val_int(void);
@@ -909,9 +907,11 @@ public:
 
   enum_field_types type() const
   {
-    return ((table && table->db_create_options & HA_OPTION_PACK_RECORD &&
-	     field_length >= 4) ?
-	    FIELD_TYPE_VAR_STRING : FIELD_TYPE_STRING);
+    return ((orig_table &&
+             orig_table->s->db_create_options & HA_OPTION_PACK_RECORD &&
+	     field_length >= 4) &&
+            orig_table->s->frm_version < FRM_VER_TRUE_VARCHAR ?
+	    MYSQL_TYPE_VAR_STRING : MYSQL_TYPE_STRING);
   }
   enum ha_base_keytype key_type() const
     { return binary() ? HA_KEYTYPE_BINARY : HA_KEYTYPE_TEXT; }
@@ -928,8 +928,9 @@ public:
   void sql_type(String &str) const;
   char *pack(char *to, const char *from, uint max_length=~(uint) 0);
   const char *unpack(char* to, const char *from);
-  int pack_cmp(const char *a,const char *b,uint key_length);
-  int pack_cmp(const char *b,uint key_length);
+  int pack_cmp(const char *a,const char *b,uint key_length,
+               my_bool insert_or_update);
+  int pack_cmp(const char *b,uint key_length,my_bool insert_or_update);
   uint packed_col_length(const char *to, uint length);
   uint max_packed_col_length(uint max_length);
   uint size_of() const { return sizeof(*this); }
@@ -937,31 +938,43 @@ public:
   bool has_charset(void) const
   { return charset() == &my_charset_bin ? FALSE : TRUE; }
   field_cast_enum field_cast_type() { return FIELD_CAST_STRING; }
+  Field *new_field(MEM_ROOT *root, struct st_table *new_table);
 };
 
 
 class Field_varstring :public Field_str {
 public:
-  Field_varstring(char *ptr_arg, uint32 len_arg,uchar *null_ptr_arg,
+  /* Store number of bytes used to store length (1 or 2) */
+  uint32 length_bytes;
+  Field_varstring(char *ptr_arg,
+                  uint32 len_arg, uint length_bytes_arg,
+                  uchar *null_ptr_arg,
 		  uchar null_bit_arg,
 		  enum utype unireg_check_arg, const char *field_name_arg,
 		  struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str(ptr_arg, len_arg, null_ptr_arg, null_bit_arg,
-	       unireg_check_arg, field_name_arg, table_arg, cs)
-  {}
+	       unireg_check_arg, field_name_arg, table_arg, cs),
+    length_bytes(length_bytes_arg)
+  {
+    if (table)
+      table->s->varchar_fields++;
+  }
   Field_varstring(uint32 len_arg,bool maybe_null_arg,
 		  const char *field_name_arg,
 		  struct st_table *table_arg, CHARSET_INFO *cs)
     :Field_str((char*) 0,len_arg, maybe_null_arg ? (uchar*) "": 0,0,
-	       NONE, field_name_arg, table_arg, cs)
-  {}
+	       NONE, field_name_arg, table_arg, cs),
+    length_bytes(len_arg < 256 ? 1 :2)
+  {
+    if (table)
+      table->s->varchar_fields++;
+  }
 
-  enum_field_types type() const { return FIELD_TYPE_VAR_STRING; }
-  enum ha_base_keytype key_type() const
-    { return binary() ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
+  enum_field_types type() const { return MYSQL_TYPE_VARCHAR; }
+  enum ha_base_keytype key_type() const;
   bool zero_pack() const { return 0; }
-  void reset(void) { bzero(ptr,field_length+2); }
-  uint32 pack_length() const { return (uint32) field_length+2; }
+  void reset(void) { bzero(ptr,field_length+length_bytes); }
+  uint32 pack_length() const { return (uint32) field_length+length_bytes; }
   uint32 key_length() const { return (uint32) field_length; }
   int  store(const char *to,uint length,CHARSET_INFO *charset);
   int  store(longlong nr);
@@ -971,21 +984,31 @@ public:
   String *val_str(String*,String *);
   int cmp(const char *,const char*);
   void sort_string(char *buff,uint length);
-  void get_key_image(char *buff,uint length, CHARSET_INFO *cs, imagetype type);
-  void set_key_image(char *buff,uint length, CHARSET_INFO *cs);
+  void get_key_image(char *buff,uint length, imagetype type);
+  void set_key_image(char *buff,uint length);
   void sql_type(String &str) const;
   char *pack(char *to, const char *from, uint max_length=~(uint) 0);
   char *pack_key(char *to, const char *from, uint max_length);
+  char *pack_key_from_key_image(char* to, const char *from, uint max_length);
   const char *unpack(char* to, const char *from);
-  int pack_cmp(const char *a, const char *b, uint key_length);
-  int pack_cmp(const char *b, uint key_length);
+  const char *unpack_key(char* to, const char *from, uint max_length);
+  int pack_cmp(const char *a, const char *b, uint key_length,
+               my_bool insert_or_update);
+  int pack_cmp(const char *b, uint key_length,my_bool insert_or_update);
+  int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
+  int key_cmp(const byte *,const byte*);
+  int key_cmp(const byte *str, uint length);
   uint packed_col_length(const char *to, uint length);
   uint max_packed_col_length(uint max_length);
   uint size_of() const { return sizeof(*this); }
-  enum_field_types real_type() const { return FIELD_TYPE_VAR_STRING; }
+  enum_field_types real_type() const { return MYSQL_TYPE_VARCHAR; }
   bool has_charset(void) const
   { return charset() == &my_charset_bin ? FALSE : TRUE; }
   field_cast_enum field_cast_type() { return FIELD_CAST_VARSTRING; }
+  Field *new_field(MEM_ROOT *root, struct st_table *new_table);
+  Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
+                       char *new_ptr, uchar *new_null_ptr,
+                       uint new_null_bit);
 };
 
 
@@ -1008,7 +1031,7 @@ public:
   }
   enum_field_types type() const { return FIELD_TYPE_BLOB;}
   enum ha_base_keytype key_type() const
-    { return binary() ? HA_KEYTYPE_VARBINARY : HA_KEYTYPE_VARTEXT; }
+    { return binary() ? HA_KEYTYPE_VARBINARY2 : HA_KEYTYPE_VARTEXT2; }
   int  store(const char *to,uint length,CHARSET_INFO *charset);
   int  store(double nr);
   int  store(longlong nr);
@@ -1017,15 +1040,13 @@ public:
   String *val_str(String*,String *);
   int cmp(const char *,const char*);
   int cmp(const char *a, uint32 a_length, const char *b, uint32 b_length);
-  int cmp_offset(uint offset);
   int cmp_binary(const char *a,const char *b, uint32 max_length=~0L);
-  int cmp_binary_offset(uint row_offset);
   int key_cmp(const byte *,const byte*);
   int key_cmp(const byte *str, uint length);
   uint32 key_length() const { return 0; }
   void sort_string(char *buff,uint length);
   uint32 pack_length() const
-  { return (uint32) (packlength+table->blob_ptr_size); }
+  { return (uint32) (packlength+table->s->blob_ptr_size); }
   inline uint32 max_data_length() const
   {
     return (uint32) (((ulonglong) 1 << (packlength*8)) -1);
@@ -1051,8 +1072,8 @@ public:
       store_length(length);
       memcpy_fixed(ptr+packlength,&data,sizeof(char*));
     }
-  void get_key_image(char *buff,uint length, CHARSET_INFO *cs, imagetype type);
-  void set_key_image(char *buff,uint length, CHARSET_INFO *cs);
+  void get_key_image(char *buff,uint length, imagetype type);
+  void set_key_image(char *buff,uint length);
   void sql_type(String &str) const;
   inline bool copy()
   { char *tmp;
@@ -1066,12 +1087,13 @@ public:
     return 0;
   }
   char *pack(char *to, const char *from, uint max_length= ~(uint) 0);
-  const char *unpack(char *to, const char *from);
   char *pack_key(char *to, const char *from, uint max_length);
   char *pack_key_from_key_image(char* to, const char *from, uint max_length);
+  const char *unpack(char *to, const char *from);
   const char *unpack_key(char* to, const char *from, uint max_length);
-  int pack_cmp(const char *a, const char *b, uint key_length);
-  int pack_cmp(const char *b, uint key_length);
+  int pack_cmp(const char *a, const char *b, uint key_length,
+               my_bool insert_or_update);
+  int pack_cmp(const char *b, uint key_length,my_bool insert_or_update);
   uint packed_col_length(const char *col_ptr, uint length);
   uint max_packed_col_length(uint max_length);
   void free() { value.free(); }
@@ -1084,6 +1106,7 @@ public:
   uint32 max_length();
 };
 
+
 #ifdef HAVE_SPATIAL
 class Field_geom :public Field_blob {
 public:
@@ -1101,19 +1124,19 @@ public:
      :Field_blob(len_arg, maybe_null_arg, field_name_arg,
                  table_arg, &my_charset_bin)
   { geom_type= geom_type_arg; }
-  enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY; }
+  enum ha_base_keytype key_type() const { return HA_KEYTYPE_VARBINARY2; }
   enum_field_types type() const { return FIELD_TYPE_GEOMETRY; }
   void sql_type(String &str) const;
   int  store(const char *to, uint length, CHARSET_INFO *charset);
   int  store(double nr) { return 1; }
   int  store(longlong nr) { return 1; }
 
-  void get_key_image(char *buff,uint length, CHARSET_INFO *cs,imagetype type);
-  void set_key_image(char *buff,uint length, CHARSET_INFO *cs);
+  void get_key_image(char *buff,uint length,imagetype type);
   field_cast_enum field_cast_type() { return FIELD_CAST_GEOM; }
 };
 #endif /*HAVE_SPATIAL*/
 
+
 class Field_enum :public Field_str {
 protected:
   uint packlength;
@@ -1182,6 +1205,52 @@ public:
 };
 
 
+class Field_bit :public Field {
+public:
+  uchar *bit_ptr;     // position in record where 'uneven' bits store
+  uchar bit_ofs;      // offset to 'uneven' high bits
+  uint bit_len;       // number of 'uneven' high bits
+  Field_bit(char *ptr_arg, uint32 len_arg, uchar *null_ptr_arg,
+            uchar null_bit_arg, uchar *bit_ptr_arg, uchar bit_ofs_arg,
+            enum utype unireg_check_arg, const char *field_name_arg,
+            struct st_table *table_arg);
+  enum_field_types type() const { return FIELD_TYPE_BIT; }
+  enum ha_base_keytype key_type() const { return HA_KEYTYPE_BIT; }
+  uint32 key_length() const { return (uint32) field_length + (bit_len > 0); }
+  uint32 max_length() { return (uint32) field_length + (bit_len > 0); }
+  uint size_of() const { return sizeof(*this); }
+  Item_result result_type () const { return INT_RESULT; }
+  void reset(void) { bzero(ptr, field_length); }
+  int store(const char *to, uint length, CHARSET_INFO *charset);
+  int store(double nr);
+  int store(longlong nr);
+  double val_real(void);
+  longlong val_int(void);
+  String *val_str(String*, String *);
+  int cmp(const char *a, const char *b)
+  { return cmp_binary(a, b); }
+  int key_cmp(const byte *a, const byte *b)
+  { return cmp_binary((char *) a, (char *) b); }
+  int key_cmp(const byte *str, uint length);
+  int cmp_offset(uint row_offset);
+  void get_key_image(char *buff, uint length, imagetype type);
+  void set_key_image(char *buff, uint length)
+  { Field_bit::store(buff, length, &my_charset_bin); }
+  void sort_string(char *buff, uint length)
+  { get_key_image(buff, length, itRAW); }
+  uint32 pack_length() const 
+  { return (uint32) field_length + (bit_len > 0); }
+  uint32 pack_length_in_rec() const { return field_length; }
+  void sql_type(String &str) const;
+  field_cast_enum field_cast_type() { return FIELD_CAST_BIT; }
+  char *pack(char *to, const char *from, uint max_length=~(uint) 0);
+  const char *unpack(char* to, const char *from);
+  Field *new_key_field(MEM_ROOT *root, struct st_table *new_table,
+                       char *new_ptr, uchar *new_null_ptr,
+                       uint new_null_bit);
+};
+
+  
 /*
   Create field class for CREATE TABLE
 */
@@ -1194,8 +1263,8 @@ public:
   LEX_STRING comment;			// Comment for field
   Item	*def;				// Default value
   enum	enum_field_types sql_type;
-  uint32 length;
-  uint decimals,flags,pack_length;
+  ulong length;
+  uint  decimals, flags, pack_length, key_length;
   Field::utype unireg_check;
   TYPELIB *interval;			// Which interval to use
   List<String> interval_list;
@@ -1260,11 +1329,10 @@ Field *make_field(char *ptr, uint32 field_length,
 		  TYPELIB *interval, const char *field_name,
 		  struct st_table *table);
 uint pack_length_to_packflag(uint type);
+enum_field_types get_blob_type_from_length(ulong length);
 uint32 calc_pack_length(enum_field_types type,uint32 length);
 int set_field_to_null(Field *field);
 int set_field_to_null_with_conversions(Field *field, bool no_conversions);
-bool test_if_int(const char *str, int length, const char *int_end,
-		 CHARSET_INFO *cs);
 bool field_types_to_be_kept(enum_field_types field_type);
 
 /*
@@ -1284,6 +1352,7 @@ bool field_types_to_be_kept(enum_field_types field_type);
 #define FIELDFLAG_LEFT_FULLSCREEN	8192
 #define FIELDFLAG_RIGHT_FULLSCREEN	16384
 #define FIELDFLAG_FORMAT_NUMBER		16384	// predit: ###,,## in output
+#define FIELDFLAG_NO_DEFAULT		16384   /* sql */
 #define FIELDFLAG_SUM			((uint) 32768)// predit: +#fieldflag
 #define FIELDFLAG_MAYBE_NULL		((uint) 32768)// sql
 #define FIELDFLAG_PACK_SHIFT		3
@@ -1292,8 +1361,6 @@ bool field_types_to_be_kept(enum_field_types field_type);
 #define FIELDFLAG_NUM_SCREEN_TYPE	0x7F01
 #define FIELDFLAG_ALFA_SCREEN_TYPE	0x7800
 
-#define FIELD_SORT_REVERSE		16384
-
 #define MTYP_TYPENR(type) (type & 127)	/* Remove bits from type */
 
 #define f_is_dec(x)		((x) & FIELDFLAG_DECIMAL)
@@ -1311,3 +1378,4 @@ bool field_types_to_be_kept(enum_field_types field_type);
 #define f_is_equ(x)		((x) & (1+2+FIELDFLAG_PACK+31*256))
 #define f_settype(x)		(((int) x) << FIELDFLAG_PACK_SHIFT)
 #define f_maybe_null(x)		(x & FIELDFLAG_MAYBE_NULL)
+#define f_no_default(x)		(x & FIELDFLAG_NO_DEFAULT)

From 7a3c7a7f7c89031be489524715666bf232ef0c5c Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Fri, 4 Feb 2005 12:59:02 -0800
Subject: [PATCH 09/17] Update test results

mysql-test/r/func_group.result:
  Update results
---
 mysql-test/r/func_group.result | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/mysql-test/r/func_group.result b/mysql-test/r/func_group.result
index 706bf4c5c6b..fdadd378ceb 100644
--- a/mysql-test/r/func_group.result
+++ b/mysql-test/r/func_group.result
@@ -742,10 +742,10 @@ insert into t1 values (now());
 create table t2 select f2 from (select max(now()) f2 from t1) a;
 show columns from t2;
 Field	Type	Null	Key	Default	Extra
-f2	datetime			0000-00-00 00:00:00	
+f2	datetime	NO		0000-00-00 00:00:00	
 drop table t2;
 create table t2 select f2 from (select now() f2 from t1) a;
 show columns from t2;
 Field	Type	Null	Key	Default	Extra
-f2	datetime			0000-00-00 00:00:00	
+f2	datetime	NO		0000-00-00 00:00:00	
 drop table t2, t1;

From ededf83143df115f5feaabbbcfeea2494d7d65d5 Mon Sep 17 00:00:00 2001
From: unknown <guilhem@mysql.com>
Date: Fri, 4 Feb 2005 22:43:54 +0100
Subject: [PATCH 10/17] Fix for BUG#8055 "Trouble with replication from
 temporary tables and ignores": when we close the session's temp tables at
 session end, we automatically write to binlog *one* DROP TEMPORARY TABLE *per
 tmp table*.

mysql-test/r/drop_temp_table.result:
  result update (note: one DROP TEMPORARY TABLE per tmp table)
mysql-test/t/drop_temp_table.test:
  checking that we have one DROP TEMPORARY TABLE per tmp table now, not one multi-table DROP.
  Hiding columns Log_pos/End_log_pos per Monty's request.
sql/sql_base.cc:
  When we close the session's temp tables at session end, we automatically write to binlog one DROP TEMPORARY TABLE per tmp table,
  not one single multi-table DROP TEMPORARY TABLE (because it causes problems if slave has --replicate*table rules).
---
 mysql-test/r/drop_temp_table.result | 16 ++++---
 mysql-test/t/drop_temp_table.test   |  3 ++
 sql/sql_base.cc                     | 66 ++++++++++++++---------------
 3 files changed, 45 insertions(+), 40 deletions(-)

diff --git a/mysql-test/r/drop_temp_table.result b/mysql-test/r/drop_temp_table.result
index 266196877c8..a486964feb2 100644
--- a/mysql-test/r/drop_temp_table.result
+++ b/mysql-test/r/drop_temp_table.result
@@ -1,7 +1,9 @@
 reset master;
 create database `drop-temp+table-test`;
 use `drop-temp+table-test`;
+create temporary table shortn1 (a int);
 create temporary table `table:name` (a int);
+create temporary table shortn2 (a int);
 select get_lock("a",10);
 get_lock("a",10)
 1
@@ -10,9 +12,13 @@ get_lock("a",10)
 1
 show binlog events;
 Log_name	Pos	Event_type	Server_id	Orig_log_pos	Info
-master-bin.000001	4	Start	1	4	Server ver: VERSION, Binlog ver: 3
-master-bin.000001	79	Query	1	79	create database `drop-temp+table-test`
-master-bin.000001	168	Query	1	168	use `drop-temp+table-test`; create temporary table `table:name` (a int)
-master-bin.000001	262	Query	1	262	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`table:name`
-master-bin.000001	391	Query	1	391	use `drop-temp+table-test`; DO RELEASE_LOCK("a")
+master-bin.000001	#	Start	1	#	Server ver: VERSION, Binlog ver: 3
+master-bin.000001	#	Query	1	#	create database `drop-temp+table-test`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table shortn1 (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table `table:name` (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table shortn2 (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`shortn2`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`table:name`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`shortn1`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DO RELEASE_LOCK("a")
 drop database `drop-temp+table-test`;
diff --git a/mysql-test/t/drop_temp_table.test b/mysql-test/t/drop_temp_table.test
index 1a7d8796bb3..dcd95721179 100644
--- a/mysql-test/t/drop_temp_table.test
+++ b/mysql-test/t/drop_temp_table.test
@@ -4,7 +4,9 @@ connection con1;
 reset master;
 create database `drop-temp+table-test`;
 use `drop-temp+table-test`;
+create temporary table shortn1 (a int);
 create temporary table `table:name` (a int);
+create temporary table shortn2 (a int);
 select get_lock("a",10);
 disconnect con1;
 
@@ -15,5 +17,6 @@ connection con2;
 select get_lock("a",10);
 let $VERSION=`select version()`;
 --replace_result $VERSION VERSION
+--replace_column 2 # 5 #
 show binlog events;
 drop database `drop-temp+table-test`;
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 7434897ab90..fe1f268e277 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -485,62 +485,58 @@ void close_temporary(TABLE *table,bool delete_table)
 void close_temporary_tables(THD *thd)
 {
   TABLE *table,*next;
-  char *query, *end;
-  uint query_buf_size; 
-  bool found_user_tables = 0;
+  char *query, *name_in_query, *end;
+  uint greatest_key_length= 0;
 
   if (!thd->temporary_tables)
     return;
   
+  /*
+    We write a DROP TEMPORARY TABLE for each temp table left, so that our
+    replication slave can clean them up. Not one multi-table DROP TABLE binlog
+    event: this would cause problems if slave uses --replicate-*-table.
+  */
   LINT_INIT(end);
-  query_buf_size= 50;   // Enough for DROP ... TABLE IF EXISTS
 
+  /* We'll re-use always same buffer so make it big enough for longest name */
   for (table=thd->temporary_tables ; table ; table=table->next)
-    /*
-      We are going to add 4 ` around the db/table names, so 1 does not look
-      enough; indeed it is enough, because table->key_length is greater (by 8,
-      because of server_id and thread_id) than db||table.
-    */
-    query_buf_size+= table->key_length+1;
+    greatest_key_length= max(greatest_key_length, table->key_length);
 
-  if ((query = alloc_root(thd->mem_root, query_buf_size)))
+  if ((query = alloc_root(thd->mem_root, greatest_key_length+50)))
     // Better add "if exists", in case a RESET MASTER has been done
-    end=strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS ");
+    name_in_query= strmov(query, "DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `");
 
   for (table=thd->temporary_tables ; table ; table=next)
   {
-    if (query) // we might be out of memory, but this is not fatal
+    /*
+      In we are OOM for 'query' this is not fatal. We skip temporary tables
+      not created directly by the user.
+    */
+    if (query && mysql_bin_log.is_open() && (table->real_name[0] != '#'))
     {
-      // skip temporary tables not created directly by the user
-      if (table->real_name[0] != '#')
-	found_user_tables = 1;
       /*
         Here we assume table_cache_key always starts
         with \0 terminated db name
       */
-      end = strxmov(end,"`",table->table_cache_key,"`.`",
-                    table->real_name,"`,", NullS);
+      end = strxmov(name_in_query, table->table_cache_key, "`.`",
+                    table->real_name, "`", NullS);
+      Query_log_event qinfo(thd, query, (ulong)(end-query), 0, FALSE);
+      /*
+        Imagine the thread had created a temp table, then was doing a SELECT, and
+        the SELECT was killed. Then it's not clever to mark the statement above as
+        "killed", because it's not really a statement updating data, and there
+        are 99.99% chances it will succeed on slave. And, if thread is
+        killed now, it's not clever either.
+        If a real update (one updating a persistent table) was killed on the
+        master, then this real update will be logged with error_code=killed,
+        rightfully causing the slave to stop.
+      */
+      qinfo.error_code= 0;
+      mysql_bin_log.write(&qinfo);
     }
     next=table->next;
     close_temporary(table);
   }
-  if (query && found_user_tables && mysql_bin_log.is_open())
-  {
-    /* The -1 is to remove last ',' */
-    thd->clear_error();
-    Query_log_event qinfo(thd, query, (ulong)(end-query)-1, 0, FALSE);
-    /*
-      Imagine the thread had created a temp table, then was doing a SELECT, and
-      the SELECT was killed. Then it's not clever to mark the statement above as
-      "killed", because it's not really a statement updating data, and there
-      are 99.99% chances it will succeed on slave.
-      If a real update (one updating a persistent table) was killed on the
-      master, then this real update will be logged with error_code=killed,
-      rightfully causing the slave to stop.
-    */
-    qinfo.error_code= 0;
-    mysql_bin_log.write(&qinfo);
-  }
   thd->temporary_tables=0;
 }
 

From 987e620d6376ae3b9047d1185dca7141585173ac Mon Sep 17 00:00:00 2001
From: unknown <guilhem@mysql.com>
Date: Fri, 4 Feb 2005 23:07:10 +0100
Subject: [PATCH 11/17] Backport of ChangeSet 1.1845 05/02/04 13:53:16
 guilhem@mysql.com +1 -0 from 5.0. Proposal to fix this problem: when using
 libmysqlclient, you must call mysql_server_end() to nicely free memory at the
 end of your program; it however sounds weird to call a function named
 *SERVER_end* when you're the CLIENT (you're not ending the server, you're
 ending your ability to talk to servers). So here I add two defines which
 should be more generic names. Our manual mentions these functions only for
 libmysqld API so needs some fixing, and then we can close BUG#8099 and
 BUG#6149.

include/mysql.h:
  Creating synonyms (defines): mysql_library_init for mysql_server_init, mysql_library_end for mysql_server_end;
  these new names are more generic, so suitable when using libmysqlclient as well as libmysqld.
---
 include/mysql.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/include/mysql.h b/include/mysql.h
index 2c0197e2300..d8a56126756 100644
--- a/include/mysql.h
+++ b/include/mysql.h
@@ -334,6 +334,17 @@ typedef struct st_mysql_parameters
 */
 int STDCALL mysql_server_init(int argc, char **argv, char **groups);
 void STDCALL mysql_server_end(void);
+/*
+  mysql_server_init/end need to be called when using libmysqld or
+  libmysqlclient (exactly, mysql_server_init() is called by mysql_init() so
+  you don't need to call it explicitely; but you need to call
+  mysql_server_end() to free memory). The names are a bit misleading
+  (mysql_SERVER* to be used when using libmysqlCLIENT). So we add more general
+  names which suit well whether you're using libmysqld or libmysqlclient. We
+  intend to promote these aliases over the mysql_server* ones.
+*/
+#define mysql_library_init mysql_server_init
+#define mysql_library_end mysql_server_end
 
 MYSQL_PARAMETERS *STDCALL mysql_get_parameters(void);
 

From fe83a1938d51c2fe780631911282902aeae1c0a9 Mon Sep 17 00:00:00 2001
From: unknown <konstantin@mysql.com>
Date: Sat, 5 Feb 2005 01:21:16 +0300
Subject: [PATCH 12/17] A fix for Bug#6273 "building fails on link": we should
 not use CLIENT_LIBS in mysql_config as CLIENT_LIBS point to builddir when we
 use the bundled zlib.

acinclude.m4:
  Extend MYSQL_CHECK_ZLIB_WITH_COMPRESS m4 macro to substitute ZLIB_DEPS -
  this is a special version of ZLIB_LIBS to use in mysql_config
configure.in:
  Remove NON_THREADED_CLIENT_LIBS which weren't really
  NON_THREADED_CLIENT_LIBS and use NON_THREADED_LIBS instead.
  AC_SUBST NON_THREADED_LIBS and STATIC_NSS_FLAGS as they're now
  needed inside mysql_config.sh
scripts/Makefile.am:
  Add STATIC_NSS_FLAGS, NON_THREADED_LIBS and ZLIB_DEPS to sed
  substitution list.
scripts/mysql_config.sh:
  We can't use CLIENT_LIBS as in case when we use the bundled zlib
  it has a reference to $(top_builddir)/zlib.
  libs and libs_r now need to be specified explicitly.
zlib/Makefile.am:
  Install libz.la in case it's used by MySQL: this way we guarantee
  that paths printed by mysql_config are valid in all cases.
---
 acinclude.m4            | 16 +++++++++++++---
 configure.in            | 16 ++++++++++------
 scripts/Makefile.am     |  3 +++
 scripts/mysql_config.sh |  7 ++++---
 zlib/Makefile.am        |  2 +-
 5 files changed, 31 insertions(+), 13 deletions(-)

diff --git a/acinclude.m4 b/acinclude.m4
index d7e22332655..5ddd8952c42 100644
--- a/acinclude.m4
+++ b/acinclude.m4
@@ -194,6 +194,8 @@ dnl Define zlib paths to point at bundled zlib
 AC_DEFUN([MYSQL_USE_BUNDLED_ZLIB], [
 ZLIB_INCLUDES="-I\$(top_srcdir)/zlib"
 ZLIB_LIBS="\$(top_builddir)/zlib/libz.la"
+dnl Omit -L$pkglibdir as it's always in the list of mysql_config deps.
+ZLIB_DEPS="-lz"
 zlib_dir="zlib"
 AC_SUBST([zlib_dir])
 mysql_cv_compress="yes"
@@ -235,8 +237,13 @@ dnl   $prefix/lib. If zlib headers or binaries weren't found at $prefix, the
 dnl   macro bails out with error.
 dnl 
 dnl If the library was found, this function #defines HAVE_COMPRESS
-dnl and configure variables ZLIB_INCLUDES (i.e. -I/path/to/zlib/include) and
-dnl ZLIB_LIBS (i. e. -L/path/to/zlib/lib -lz).
+dnl and configure variables ZLIB_INCLUDES (i.e. -I/path/to/zlib/include),
+dnl ZLIB_LIBS (i. e. -L/path/to/zlib/lib -lz) and ZLIB_DEPS which is
+dnl used in mysql_config and is always the same as ZLIB_LIBS except to
+dnl when we use the bundled zlib. In the latter case ZLIB_LIBS points to the
+dnl build dir ($top_builddir/zlib), while mysql_config must point to the
+dnl installation dir ($pkglibdir), so ZLIB_DEPS is set to point to
+dnl $pkglibdir.
 
 AC_DEFUN([MYSQL_CHECK_ZLIB_WITH_COMPRESS], [
 AC_MSG_CHECKING([for zlib compression library])
@@ -285,7 +292,11 @@ case $SYSTEM_TYPE in
         ;;
     esac
     if test "$mysql_cv_compress" = "yes"; then
+      if test "x$ZLIB_DEPS" = "x"; then
+        ZLIB_DEPS="$ZLIB_LIBS"
+      fi
       AC_SUBST([ZLIB_LIBS])
+      AC_SUBST([ZLIB_DEPS])
       AC_SUBST([ZLIB_INCLUDES])
       AC_DEFINE([HAVE_COMPRESS], [1], [Define to enable compression support])
     fi
@@ -1039,7 +1050,6 @@ AC_MSG_CHECKING(for OpenSSL)
       echo "You can't use the --all-static link option when using openssl."
       exit 1
     fi
-    NON_THREADED_CLIENT_LIBS="$NON_THREADED_CLIENT_LIBS $openssl_libs"
   else
     AC_MSG_RESULT(no)
 	if test ! -z "$openssl_includes"
diff --git a/configure.in b/configure.in
index caa42004736..665029accb3 100644
--- a/configure.in
+++ b/configure.in
@@ -924,9 +924,11 @@ if test "$ac_cv_header_termio_h" = "no" -a "$ac_cv_header_termios_h" = "no"
 then
   AC_CHECK_FUNC(gtty, , AC_CHECK_LIB(compat, gtty))
 fi
-# We make a special variable for client library's to avoid including
-# thread libs in the client.
-NON_THREADED_CLIENT_LIBS="$LIBS $ZLIB_LIBS"
+
+# We make a special variable for non-threaded version of LIBS to avoid
+# including thread libs into non-threaded version of MySQL client library.
+# Later in this script LIBS will be augmented with a threads library.
+NON_THREADED_LIBS="$LIBS"
 
 AC_MSG_CHECKING([for int8])
 case $SYSTEM_TYPE in
@@ -1502,7 +1504,7 @@ then
   if test -f /usr/lib/libxnet.so -a "$SYSTEM_TYPE" = "sni-sysv4"
   then
     LIBS="-lxnet $LIBS"
-    NON_THREADED_CLIENT_LIBS="$NON_THREADED_CLIENT_LIBS -lxnet"
+    NON_THREADED_LIBS="-lxnet $NON_THREADED_LIBS"
     with_named_thread="-Kthread $LDFLAGS -lxnet"
     LD_FLAGS=""
     CFLAGS="-Kthread $CFLAGS"
@@ -2826,7 +2828,7 @@ dnl This probably should be cleaned up more - for now the threaded
 dnl client is just using plain-old libs.
 sql_client_dirs="libmysql strings regex client"
 linked_client_targets="linked_libmysql_sources"
-CLIENT_LIBS=$NON_THREADED_CLIENT_LIBS
+
 if test "$THREAD_SAFE_CLIENT" != "no"
 then
   sql_client_dirs="libmysql_r $sql_client_dirs"
@@ -2834,9 +2836,11 @@ then
   AC_DEFINE([THREAD_SAFE_CLIENT], [1], [Should be client be thread safe])
 fi
 
-CLIENT_LIBS="$CLIENT_LIBS $STATIC_NSS_FLAGS"
+CLIENT_LIBS="$NON_THREADED_LIBS $openssl_libs $ZLIB_LIBS $STATIC_NSS_FLAGS"
 
 AC_SUBST(CLIENT_LIBS)
+AC_SUBST(NON_THREADED_LIBS)
+AC_SUBST(STATIC_NSS_FLAGS)
 AC_SUBST(sql_client_dirs)
 AC_SUBST(linked_client_targets)
 
diff --git a/scripts/Makefile.am b/scripts/Makefile.am
index 71b70fc0e4a..d5337df35b1 100644
--- a/scripts/Makefile.am
+++ b/scripts/Makefile.am
@@ -140,6 +140,9 @@ SUFFIXES = .sh
 	  -e 's!@''IS_LINUX''@!@IS_LINUX@!' \
 	  -e "s!@""CONF_COMMAND""@!@CONF_COMMAND@!" \
 	  -e 's!@''MYSQLD_USER''@!@MYSQLD_USER@!' \
+	  -e 's!@''STATIC_NSS_FLAGS''@!@STATIC_NSS_FLAGS@!' \
+	  -e 's!@''NON_THREADED_LIBS''@!@NON_THREADED_LIBS@!' \
+	  -e 's!@''ZLIB_DEPS''@!@ZLIB_DEPS@!' \
 	  -e "s!@MAKE@!$(MAKE)!" \
 	$< > $@-t
 	@CHMOD@ +x $@-t
diff --git a/scripts/mysql_config.sh b/scripts/mysql_config.sh
index 90418de3d1d..a5c8af5ecb2 100644
--- a/scripts/mysql_config.sh
+++ b/scripts/mysql_config.sh
@@ -82,13 +82,14 @@ version='@VERSION@'
 socket='@MYSQL_UNIX_ADDR@'
 port='@MYSQL_TCP_PORT@'
 ldflags='@LDFLAGS@'
-client_libs='@CLIENT_LIBS@'
 
 # Create options
 
-libs="$ldflags -L$pkglibdir -lmysqlclient $client_libs"
+libs="$ldflags -L$pkglibdir -lmysqlclient @ZLIB_DEPS@ @NON_THREADED_LIBS@"
+libs="$libs @openssl_libs@ @STATIC_NSS_FLAGS@"
 libs=`echo "$libs" | sed -e 's;  \+; ;g' | sed -e 's;^ *;;' | sed -e 's; *\$;;'`
-libs_r="$ldflags -L$pkglibdir -lmysqlclient_r @LIBS@ @ZLIB_LIBS@ @openssl_libs@"
+
+libs_r="$ldflags -L$pkglibdir -lmysqlclient_r @ZLIB_DEPS@ @LIBS@ @openssl_libs@"
 libs_r=`echo "$libs_r" | sed -e 's;  \+; ;g' | sed -e 's;^ *;;' | sed -e 's; *\$;;'`
 cflags="-I$pkgincludedir @CFLAGS@ " #note: end space!
 include="-I$pkgincludedir"
diff --git a/zlib/Makefile.am b/zlib/Makefile.am
index 58d3811cd7c..e94d184a841 100644
--- a/zlib/Makefile.am
+++ b/zlib/Makefile.am
@@ -16,7 +16,7 @@
 
 # Process this file with automake to create Makefile.in
 
-noinst_LTLIBRARIES=libz.la
+pkglib_LTLIBRARIES=libz.la
 
 noinst_HEADERS= crc32.h deflate.h inffast.h inffixed.h inflate.h \
 		inftrees.h trees.h zconf.h zlib.h zutil.h

From 5cf29b3b609f7c3789cb433fc4819b350aad8409 Mon Sep 17 00:00:00 2001
From: unknown <monty@mysql.com>
Date: Sat, 5 Feb 2005 16:05:46 +0200
Subject: [PATCH 13/17] Fixed bug detected by sp-tests Cleanup during reviews
 of new pushed code

BUILD/compile-pentium-debug-max:
  Use --debug=full as default
BUILD/compile-pentium-debug:
  Use --debug=full as default
mysys/my_alloc.c:
  More debugging
sql/item_func.cc:
  Cleanup new code
  Don't call insert_id() for last_insert_id(value) to avoid side effects
sql/item_subselect.cc:
  Fixed DBUG output
sql/sp_head.cc:
  Simple cleanup
sql/sql_lex.cc:
  Moved usage of arguments first in lex_start to make their usage clearer
  Remove sl->expr_list.deleete_elements() becasue:
  - It didn't do anything (delete_elements on a list of list is a no-op operation)
  - The deleted for loop used SELECT_LEX elements that was allocated in mysql_new_select() in sp-head, but freed
  when sphead->mem_root was freed. (delete sphead doesn't remove used SELECT_LEX elements from the global all_selects_list)
sql/sql_parse.cc:
  More DBUG entries
---
 BUILD/compile-pentium-debug     |  2 +-
 BUILD/compile-pentium-debug-max |  2 +-
 mysys/my_alloc.c                |  6 ++++--
 sql/item_func.cc                | 13 +++++++------
 sql/item_subselect.cc           |  2 +-
 sql/sp_head.cc                  |  4 ++--
 sql/sql_lex.cc                  | 14 +++++++-------
 sql/sql_parse.cc                | 14 ++++++++------
 8 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/BUILD/compile-pentium-debug b/BUILD/compile-pentium-debug
index 4a9d0e74599..7957caead29 100755
--- a/BUILD/compile-pentium-debug
+++ b/BUILD/compile-pentium-debug
@@ -1,7 +1,7 @@
 #! /bin/sh
 
 path=`dirname $0`
-. "$path/SETUP.sh"
+. "$path/SETUP.sh" $@ --with-debug=full
 
 extra_flags="$pentium_cflags $debug_cflags"
 c_warnings="$c_warnings $debug_extra_warnings"
diff --git a/BUILD/compile-pentium-debug-max b/BUILD/compile-pentium-debug-max
index 420657e0b73..7a11ad24c44 100755
--- a/BUILD/compile-pentium-debug-max
+++ b/BUILD/compile-pentium-debug-max
@@ -1,7 +1,7 @@
 #! /bin/sh
 
 path=`dirname $0`
-. "$path/SETUP.sh"
+. "$path/SETUP.sh" $@ --with-debug=full
 
 extra_flags="$pentium_cflags $debug_cflags $max_cflags"
 c_warnings="$c_warnings $debug_extra_warnings"
diff --git a/mysys/my_alloc.c b/mysys/my_alloc.c
index c14b2899b4b..e0d6288f76b 100644
--- a/mysys/my_alloc.c
+++ b/mysys/my_alloc.c
@@ -166,7 +166,8 @@ gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size)
   gptr point;
   reg1 USED_MEM *next= 0;
   reg2 USED_MEM **prev;
-
+  DBUG_ENTER("alloc_root");
+  DBUG_PRINT("enter",("root: 0x%lx", mem_root));
   DBUG_ASSERT(alloc_root_inited(mem_root));
 
   Size= ALIGN_SIZE(Size);
@@ -213,7 +214,8 @@ gptr alloc_root(MEM_ROOT *mem_root,unsigned int Size)
     mem_root->used= next;
     mem_root->first_block_usage= 0;
   }
-  return(point);
+  DBUG_PRINT("exit",("ptr: 0x%lx", (ulong) point));
+  DBUG_RETURN(point);
 #endif
 }
 
diff --git a/sql/item_func.cc b/sql/item_func.cc
index 8ee1891eafd..134fb3be0e6 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -2377,16 +2377,17 @@ longlong Item_func_release_lock::val_int()
 
 longlong Item_func_last_insert_id::val_int()
 {
+  THD *thd= current_thd;
   DBUG_ASSERT(fixed == 1);
   if (arg_count)
   {
-    longlong value=args[0]->val_int();
-    current_thd->insert_id(value);
-    null_value=args[0]->null_value;
+    longlong value= args[0]->val_int();
+    thd->insert_id(value);
+    null_value= args[0]->null_value;
+    return value;                       // Avoid side effect of insert_id()
   }
-  else
-    current_thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
-  return current_thd->insert_id();
+  thd->lex->uncacheable(UNCACHEABLE_SIDEEFFECT);
+  return thd->insert_id();
 }
 
 /* This function is just used to test speed of different functions */
diff --git a/sql/item_subselect.cc b/sql/item_subselect.cc
index 3ac75bfdd30..b5cb01494fa 100644
--- a/sql/item_subselect.cc
+++ b/sql/item_subselect.cc
@@ -53,7 +53,7 @@ void Item_subselect::init(st_select_lex *select_lex,
 {
 
   DBUG_ENTER("Item_subselect::init");
-  DBUG_PRINT("subs", ("select_lex 0x%xl", (ulong) select_lex));
+  DBUG_PRINT("enter", ("select_lex: 0x%x", (ulong) select_lex));
   unit= select_lex->master_unit();
 
   if (unit->item)
diff --git a/sql/sp_head.cc b/sql/sp_head.cc
index 3f2969768c5..d52474998a8 100644
--- a/sql/sp_head.cc
+++ b/sql/sp_head.cc
@@ -424,10 +424,10 @@ sp_head::~sp_head()
 void
 sp_head::destroy()
 {
-  DBUG_ENTER("sp_head::destroy");
-  DBUG_PRINT("info", ("name: %s", m_name.str));
   sp_instr *i;
   LEX *lex;
+  DBUG_ENTER("sp_head::destroy");
+  DBUG_PRINT("info", ("name: %s", m_name.str));
 
   for (uint ip = 0 ; (i = get_instr(ip)) ; ip++)
     delete i;
diff --git a/sql/sql_lex.cc b/sql/sql_lex.cc
index 06e271333bf..0644ca5af68 100644
--- a/sql/sql_lex.cc
+++ b/sql/sql_lex.cc
@@ -115,9 +115,14 @@ void lex_free(void)
 void lex_start(THD *thd, uchar *buf,uint length)
 {
   LEX *lex= thd->lex;
+  DBUG_ENTER("lex_start");
+
+  lex->thd= lex->unit.thd= thd;
+  lex->buf= lex->ptr= buf;
+  lex->end_of_query= buf+length;
+
   lex->unit.init_query();
   lex->unit.init_select();
-  lex->thd= lex->unit.thd= thd;
   lex->select_lex.init_query();
   lex->value_list.empty();
   lex->update_list.empty();
@@ -150,8 +155,6 @@ void lex_start(THD *thd, uchar *buf,uint length)
   lex->empty_field_list_on_rset= 0;
   lex->select_lex.select_number= 1;
   lex->next_state=MY_LEX_START;
-  lex->buf= lex->ptr= buf;
-  lex->end_of_query=buf+length;
   lex->yylineno = 1;
   lex->in_comment=0;
   lex->length=0;
@@ -173,14 +176,11 @@ void lex_start(THD *thd, uchar *buf,uint length)
 
   if (lex->spfuns.records)
     my_hash_reset(&lex->spfuns);
+  DBUG_VOID_RETURN;
 }
 
 void lex_end(LEX *lex)
 {
-  for (SELECT_LEX *sl= lex->all_selects_list;
-       sl;
-       sl= sl->next_select_in_list())
-    sl->expr_list.delete_elements();	// If error when parsing sql-varargs
   x_free(lex->yacc_yyss);
   x_free(lex->yacc_yyvs);
 }
diff --git a/sql/sql_parse.cc b/sql/sql_parse.cc
index d309f58a37c..2fb90502863 100644
--- a/sql/sql_parse.cc
+++ b/sql/sql_parse.cc
@@ -4719,19 +4719,21 @@ bool
 mysql_new_select(LEX *lex, bool move_down)
 {
   SELECT_LEX *select_lex;
+  DBUG_ENTER("mysql_new_select");
+
   if (!(select_lex= new(lex->thd->mem_root) SELECT_LEX()))
-    return 1;
+    DBUG_RETURN(1);
   select_lex->select_number= ++lex->thd->select_number;
   select_lex->init_query();
   select_lex->init_select();
   select_lex->parent_lex= lex;
   if (move_down)
   {
+    SELECT_LEX_UNIT *unit;
     lex->subqueries= TRUE;
     /* first select_lex of subselect or derived table */
-    SELECT_LEX_UNIT *unit;
     if (!(unit= new(lex->thd->mem_root) SELECT_LEX_UNIT()))
-      return 1;
+      DBUG_RETURN(1);
 
     unit->init_query();
     unit->init_select();
@@ -4748,7 +4750,7 @@ mysql_new_select(LEX *lex, bool move_down)
     if (lex->current_select->order_list.first && !lex->current_select->braces)
     {
       my_error(ER_WRONG_USAGE, MYF(0), "UNION", "ORDER BY");
-      return 1;
+      DBUG_RETURN(1);
     }
     select_lex->include_neighbour(lex->current_select);
     SELECT_LEX_UNIT *unit= select_lex->master_unit();
@@ -4760,7 +4762,7 @@ mysql_new_select(LEX *lex, bool move_down)
 	fake SELECT_LEX for UNION processing
       */
       if (!(fake= unit->fake_select_lex= new(lex->thd->mem_root) SELECT_LEX()))
-        return 1;
+        DBUG_RETURN(1);
       fake->include_standalone(unit,
 			       (SELECT_LEX_NODE**)&unit->fake_select_lex);
       fake->select_number= INT_MAX;
@@ -4774,7 +4776,7 @@ mysql_new_select(LEX *lex, bool move_down)
   select_lex->include_global((st_select_lex_node**)&lex->all_selects_list);
   lex->current_select= select_lex;
   select_lex->resolve_mode= SELECT_LEX::SELECT_MODE;
-  return 0;
+  DBUG_RETURN(0);
 }
 
 /*

From 13e47c5eb9f371626adb43e0bb27b942dde96855 Mon Sep 17 00:00:00 2001
From: unknown <mskold@mysql.com>
Date: Sat, 5 Feb 2005 15:47:06 +0100
Subject: [PATCH 14/17] Fix for bug#8315 NdbScanFilter cmp method only works
 for strings of exact word boundry length

---
 ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
index 9778c938e0f..bc1700c12ad 100644
--- a/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
+++ b/ndb/src/kernel/blocks/dbtup/DbtupExecQuery.cpp
@@ -1865,6 +1865,11 @@ int Dbtup::interpreterNextLab(Signal* signal,
 	}
 	else
 	{
+	  /* --------------------------------------------------------- */
+	  // If length of argument rounded to nearest word is
+	  // the same as attribute size, use that as argument size
+	  /* --------------------------------------------------------- */
+	  if ((((argLen + 3) >> 2) << 2) == attrLen) argLen= attrLen;
 	  res = (*sqlType.m_cmp)(cs, s1, attrLen, s2, argLen, true);
 	}
 	

From d52afba56aed1623f971cd74c34c0014a0303ebc Mon Sep 17 00:00:00 2001
From: unknown <sergefp@mysql.com>
Date: Sat, 5 Feb 2005 18:16:29 +0300
Subject: [PATCH 15/17] Outer joins cleanup: Remove TABLE::outer_join and use
 TABLE::maybe_null only (2nd patch after Monty's comments).

sql/mysql_priv.h:
  Outer joins cleanup: Remove TABLE::outer_join and use TABLE::maybe_null only.
sql/opt_range.cc:
  Outer joins cleanup: Remove TABLE::outer_join and use TABLE::maybe_null only.
sql/sql_base.cc:
  Outer joins cleanup: Remove TABLE::outer_join and use TABLE::maybe_null only.
sql/sql_select.cc:
  Outer joins cleanup: Remove TABLE::outer_join and use TABLE::maybe_null only.
sql/table.h:
  Outer joins cleanup:
   * Remove TABLE::outer_join and use TABLE::maybe_null only.
   * Added comments.
---
 sql/mysql_priv.h  |  2 +-
 sql/opt_range.cc  |  2 +-
 sql/sql_base.cc   |  5 ++---
 sql/sql_select.cc |  4 ++--
 sql/table.h       | 14 +++++++++-----
 5 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/sql/mysql_priv.h b/sql/mysql_priv.h
index 6311b2d5f52..397f1ad4fb6 100644
--- a/sql/mysql_priv.h
+++ b/sql/mysql_priv.h
@@ -1329,7 +1329,7 @@ inline void setup_table_map(TABLE *table, TABLE_LIST *table_list, uint tablenr)
   table->null_row= 0;
   table->status= STATUS_NO_RECORD;
   table->keys_in_use_for_query= table->s->keys_in_use;
-  table->maybe_null= test(table->outer_join= table_list->outer_join);
+  table->maybe_null= table_list->outer_join;
   table->tablenr= tablenr;
   table->map= (table_map) 1 << tablenr;
   table->force_index= table_list->force_index;
diff --git a/sql/opt_range.cc b/sql/opt_range.cc
index e5799bfd509..ceb9f97bbbc 100644
--- a/sql/opt_range.cc
+++ b/sql/opt_range.cc
@@ -3611,7 +3611,7 @@ get_mm_leaf(PARAM *param, COND *conf_func, Field *field, KEY_PART *key_part,
 
   if (!value)					// IS NULL or IS NOT NULL
   {
-    if (field->table->outer_join)		// Can't use a key on this
+    if (field->table->maybe_null)		// Can't use a key on this
       DBUG_RETURN(0);
     if (!maybe_null)				// Not null field
       DBUG_RETURN(type == Item_func::ISNULL_FUNC ? &null_element : 0);
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 8a7ae2dffc3..44e575858b8 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -854,7 +854,7 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
   table->tablenr=thd->current_tablenr++;
   table->used_fields=0;
   table->const_table=0;
-  table->outer_join= table->null_row= table->maybe_null= table->force_index= 0;
+  table->null_row= table->maybe_null= table->force_index= 0;
   table->status=STATUS_NO_RECORD;
   table->keys_in_use_for_query= share->keys_in_use;
   table->used_keys= share->keys_for_keyread;
@@ -1078,7 +1078,7 @@ TABLE *open_table(THD *thd, TABLE_LIST *table_list, MEM_ROOT *mem_root,
   table->tablenr=thd->current_tablenr++;
   table->used_fields=0;
   table->const_table=0;
-  table->outer_join= table->null_row= table->maybe_null= table->force_index= 0;
+  table->null_row= table->maybe_null= table->force_index= 0;
   table->status=STATUS_NO_RECORD;
   table->keys_in_use_for_query= table->s->keys_in_use;
   table->insert_values= 0;
@@ -1150,7 +1150,6 @@ bool reopen_table(TABLE *table,bool locked)
   tmp.tablenr=		table->tablenr;
   tmp.used_fields=	table->used_fields;
   tmp.const_table=	table->const_table;
-  tmp.outer_join=	table->outer_join;
   tmp.null_row=		table->null_row;
   tmp.maybe_null=	table->maybe_null;
   tmp.status=		table->status;
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
index 89b84f40eb6..68438f7a785 100644
--- a/sql/sql_select.cc
+++ b/sql/sql_select.cc
@@ -9181,7 +9181,7 @@ join_read_const_table(JOIN_TAB *tab, POSITION *pos)
       tab->info="const row not found";
       /* Mark for EXPLAIN that the row was not found */
       pos->records_read=0.0;
-      if (!table->outer_join || error > 0)
+      if (!table->maybe_null || error > 0)
 	DBUG_RETURN(error);
     }
   }
@@ -9200,7 +9200,7 @@ join_read_const_table(JOIN_TAB *tab, POSITION *pos)
       tab->info="unique row not found";
       /* Mark for EXPLAIN that the row was not found */
       pos->records_read=0.0;
-      if (!table->outer_join || error > 0)
+      if (!table->maybe_null || error > 0)
 	DBUG_RETURN(error);
     }
     if (table->key_read)
diff --git a/sql/table.h b/sql/table.h
index 8240a3445ec..5d804a7837e 100644
--- a/sql/table.h
+++ b/sql/table.h
@@ -217,14 +217,18 @@ struct st_table {
   uint          derived_select_number;
   int		current_lock;           /* Type of lock on table */
   my_bool copy_blobs;			/* copy_blobs when storing */
+  
+  /* 
+    0 or JOIN_TYPE_{LEFT|RIGHT}. Currently this is only compared to 0.
+    If maybe_null !=0, this table is inner w.r.t. some outer join operation,
+    and null_row may be true.
+  */
+  uint maybe_null;
   /*
-    Used in outer joins: if true, all columns are considered to have NULL
-    values, including columns declared as "not null".
+    If true, the current table row is considered to have all columns set to 
+    NULL, including columns declared as "not null" (see maybe_null).
   */
   my_bool null_row;
-  /* 0 or JOIN_TYPE_{LEFT|RIGHT}, same as TABLE_LIST::outer_join */
-  my_bool outer_join;
-  my_bool maybe_null;                   /* true if (outer_join != 0) */
   my_bool force_index;
   my_bool distinct,const_table,no_rows;
   my_bool key_read, no_keyread;

From ac1e5aba61901d457bab083a4b40928f506637d0 Mon Sep 17 00:00:00 2001
From: unknown <jimw@mysql.com>
Date: Sat, 5 Feb 2005 08:54:13 -0800
Subject: [PATCH 16/17] Update test result

mysql-test/r/type_date.result:
  Update results
---
 mysql-test/r/type_date.result | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/mysql-test/r/type_date.result b/mysql-test/r/type_date.result
index 3428b5969d9..e88eebffb55 100644
--- a/mysql-test/r/type_date.result
+++ b/mysql-test/r/type_date.result
@@ -99,7 +99,7 @@ DROP TABLE t1, t2, t3;
 CREATE TABLE t1 (y YEAR);
 INSERT INTO t1 VALUES ('abc');
 Warnings:
-Warning	1265	Data truncated for column 'y' at row 1
+Warning	1264	Out of range value adjusted for column 'y' at row 1
 SELECT * FROM t1;
 y
 0000

From 2c0acb32d0769dadf68bda4fd59f6dc70adcc422 Mon Sep 17 00:00:00 2001
From: unknown <guilhem@mysql.com>
Date: Sat, 5 Feb 2005 19:49:02 +0100
Subject: [PATCH 17/17] result update after 4.1->5.0 merge

mysql-test/r/drop_temp_table.result:
  result update
---
 mysql-test/r/drop_temp_table.result | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/mysql-test/r/drop_temp_table.result b/mysql-test/r/drop_temp_table.result
index 8a2a75f1723..163fc845e88 100644
--- a/mysql-test/r/drop_temp_table.result
+++ b/mysql-test/r/drop_temp_table.result
@@ -1,7 +1,9 @@
 reset master;
 create database `drop-temp+table-test`;
 use `drop-temp+table-test`;
+create temporary table shortn1 (a int);
 create temporary table `table:name` (a int);
+create temporary table shortn2 (a int);
 select get_lock("a",10);
 get_lock("a",10)
 1
@@ -10,9 +12,13 @@ get_lock("a",10)
 1
 show binlog events;
 Log_name	Pos	Event_type	Server_id	End_log_pos	Info
-master-bin.000001	4	Format_desc	1	95	Server ver: VERSION, Binlog ver: 4
-master-bin.000001	95	Query	1	213	create database `drop-temp+table-test`
-master-bin.000001	213	Query	1	336	use `drop-temp+table-test`; create temporary table `table:name` (a int)
-master-bin.000001	336	Query	1	494	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`table:name`
-master-bin.000001	494	Query	1	594	use `drop-temp+table-test`; DO RELEASE_LOCK("a")
+master-bin.000001	#	Format_desc	1	#	Server ver: VERSION, Binlog ver: 4
+master-bin.000001	#	Query	1	#	create database `drop-temp+table-test`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table shortn1 (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table `table:name` (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; create temporary table shortn2 (a int)
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`shortn2`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`table:name`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DROP /*!40005 TEMPORARY */ TABLE IF EXISTS `drop-temp+table-test`.`shortn1`
+master-bin.000001	#	Query	1	#	use `drop-temp+table-test`; DO RELEASE_LOCK("a")
 drop database `drop-temp+table-test`;