Merge pgalbraith@bk-internal.mysql.com:/home/bk/mysql-5.0

into  krsna.patg.net:/home/patg/mysql-build/mysql-5.0.test2

client/mysql.cc

@@ -1133,10 +1133,11 @@ static COMMANDS *find_command(char *name,char cmd_char)
       parsing the row and calling find_command()
     */
     if (strstr(name, "\\g") || (strstr(name, delimiter) &&
-                                strlen(name) >= 9 &&
-                                my_strnncoll(charset_info,(uchar*) name,
-                                             9,
-                                             (const uchar*) "delimiter", 9)))
+                                !(strlen(name) >= 9 &&
+                                  !my_strnncoll(charset_info,
+                                                (uchar*) name, 9,
+                                                (const uchar*) "delimiter",
+                                                9))))
       DBUG_RETURN((COMMANDS *) 0);
     if ((end=strcont(name," \t")))
     {

client/mysqltest.c

@@ -3616,19 +3616,24 @@ static int run_query_stmt(MYSQL *mysql, struct st_query *q, int flags)
         /* Read result from each column */
         for (col_idx= 0; col_idx < num_fields; col_idx++)
         {
-          /* FIXME is string terminated? */
-          const char *val= (const char *)bind[col_idx].buffer;
-          ulonglong len= *bind[col_idx].length;
+          const char *val;
+          ulonglong len;
           if (col_idx < max_replace_column && replace_column[col_idx])
           {
             val= replace_column[col_idx];
             len= strlen(val);
           }
-          if (*bind[col_idx].is_null)
+          else if (*bind[col_idx].is_null)
           {
             val= "NULL";
             len= 4;
           }
+          else
+          {
+            /* FIXME is string terminated? */
+            val= (const char *) bind[col_idx].buffer;
+            len= *bind[col_idx].length;
+          }
           if (!display_result_vertically)
           {
             if (col_idx)                      /* No tab before first col */

myisam/mi_check.c

@@ -1848,7 +1848,7 @@ static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
 	if (sort_one_index(param,info,keyinfo,next_page,new_file))
 	{
 	  DBUG_PRINT("error",
-		     ("From page: %ld, keyoffset: 0x%lx  used_length: %d",
+		     ("From page: %ld, keyoffset: %lu  used_length: %d",
 		      (ulong) pagepos, (ulong) (keypos - buff),
 		      (int) used_length));
 	  DBUG_DUMP("buff",(byte*) buff,used_length);

mysql-test/r/bdb.result

@@ -1584,8 +1584,6 @@ g         	10
 h         	10
 i         	10
 alter table t1 modify v varchar(300), drop key v, drop key v_2, add key v (v);
-Warnings:
-Warning	1071	Specified key was too long; max key length is 255 bytes
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -1594,7 +1592,7 @@ t1	CREATE TABLE `t1` (
   `t` text,
   KEY `c` (`c`),
   KEY `t` (`t`(10)),
-  KEY `v` (`v`(255))
+  KEY `v` (`v`)
 ) ENGINE=BerkeleyDB DEFAULT CHARSET=latin1
 select count(*) from t1 where v='a';
 count(*)
@@ -1616,19 +1614,19 @@ count(*)
 9
 explain select count(*) from t1 where v='a  ';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	v	v	258	const	#	Using where
+1	SIMPLE	t1	ref	v	v	303	const	#	Using where
 explain select count(*) from t1 where v like 'a%';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	range	v	v	258	NULL	#	Using where
+1	SIMPLE	t1	range	v	v	303	NULL	#	Using where
 explain select count(*) from t1 where v between 'a' and 'a ';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	v	v	258	const	#	Using where
+1	SIMPLE	t1	ref	v	v	303	const	#	Using where
 explain select count(*) from t1 where v between 'a' and 'a ' and v between 'a  ' and 'b\n';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	v	v	258	const	#	Using where
+1	SIMPLE	t1	ref	v	v	303	const	#	Using where
 explain select * from t1 where v='a';
 id	select_type	table	type	possible_keys	key	key_len	ref	rows	Extra
-1	SIMPLE	t1	ref	v	v	258	const	#	Using where
+1	SIMPLE	t1	ref	v	v	303	const	#	Using where
 select v,count(*) from t1 group by v limit 10;
 v	count(*)
 a
	1
@@ -1746,8 +1744,6 @@ g         	10
 h         	10
 i         	10
 alter table t1 modify v varchar(600), drop key v, add key v (v);
-Warnings:
-Warning	1071	Specified key was too long; max key length is 255 bytes
 show create table t1;
 Table	Create Table
 t1	CREATE TABLE `t1` (
@@ -1756,7 +1752,7 @@ t1	CREATE TABLE `t1` (
   `t` text,
   KEY `c` (`c`),
   KEY `t` (`t`(10)),
-  KEY `v` (`v`(255))
+  KEY `v` (`v`)
 ) ENGINE=BerkeleyDB DEFAULT CHARSET=latin1
 select v,count(*) from t1 group by v limit 10;
 v	count(*)
@@ -1874,7 +1870,7 @@ a	b
 drop table t1;
 create table t1 (v varchar(65530), key(v));
 Warnings:
-Warning	1071	Specified key was too long; max key length is 255 bytes
+Warning	1071	Specified key was too long; max key length is 1024 bytes
 drop table if exists t1;
 create table t1 (v varchar(65536));
 Warnings:

mysql-test/r/update.result

@@ -337,3 +337,11 @@ a	b
 22	3
 23	3
 drop table t1;
+create table t1 (f1 date not null);
+insert into t1 values('2000-01-01'),('0000-00-00');
+update t1 set f1='2002-02-02' where f1 is null;
+select * from t1;
+f1
+2000-01-01
+2002-02-02
+drop table t1;

mysql-test/t/update.test

@@ -260,5 +260,14 @@ update t1 set a=a+11,b=2 order by a limit 3;
 update t1 set a=a+12,b=3 order by a limit 3;
 select * from t1 order by a;
 
+drop table t1;
+
+#
+# Bug#14186 select datefield is null not updated
+#
+create table t1 (f1 date not null);
+insert into t1 values('2000-01-01'),('0000-00-00');
+update t1 set f1='2002-02-02' where f1 is null;
+select * from t1;
 drop table t1;
 # End of 4.1 tests

mysys/base64.c

@@ -27,9 +27,13 @@ static char base64_table[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 int
 base64_needed_encoded_length(int length_of_data)
 {
-  return ceil(length_of_data * 4 / 3) /* base64 chars */ +
-    ceil(length_of_data / (76 * 3 / 4)) /* Newlines */ +
-    3 /* Padding */;
+  int nb_base64_chars;
+  nb_base64_chars= (length_of_data + 2) / 3 * 4;
+
+  return
+    nb_base64_chars +            /* base64 char incl padding */
+    (nb_base64_chars - 1)/ 76 +  /* newlines */
+    1;                           /* NUL termination of string */
 }
 
 
@@ -89,6 +93,7 @@ base64_encode(const void *src, size_t src_len, char *dst)
     else
       *dst++= base64_table[(c >> 0) & 0x3f];
   }
+  *dst= '\0';
 
   return 0;
 }
@@ -209,6 +214,7 @@ main(void)
   size_t j;
   size_t k, l;
   size_t dst_len;
+  size_t needed_length;
 
   for (i= 0; i < 500; i++)
   {
@@ -227,8 +233,12 @@ main(void)
     }
 
     /* Encode */
-    str= (char *) malloc(base64_needed_encoded_length(src_len));
+    needed_length= base64_needed_encoded_length(src_len);
+    str= (char *) malloc(needed_length);
+    for (k= 0; k < needed_length; k++)
+      str[k]= 0xff; /* Fill memory to check correct NUL termination */
     require(base64_encode(src, src_len, str) == 0);
+    require(needed_length == strlen(str) + 1);
 
     /* Decode */
     dst= (char *) malloc(base64_needed_decoded_length(strlen(str)));

scripts/mysqld_safe.sh

@@ -11,6 +11,7 @@
 # executing mysqld_safe
 
 KILL_MYSQLD=1;
+MYSQLD=
 
 trap '' 1 2 3 15			# we shouldn't let anyone kill us
 
@@ -174,14 +175,6 @@ export MYSQL_HOME
 user=@MYSQLD_USER@
 niceness=0
 
-# Use the mysqld-max binary by default if the user doesn't specify a binary
-if test -x $ledir/mysqld-max
-then
-  MYSQLD=mysqld-max
-else
-  MYSQLD=mysqld
-fi
-
 # these rely on $DATADIR by default, so we'll set them later on
 pid_file=
 err_log=
@@ -220,6 +213,16 @@ then
   chown $user $mysql_unix_port_dir
 fi
 
+# Use the mysqld-max binary by default if the user doesn't specify a binary
+if test -z "$MYSQLD"
+then
+  if test -x $ledir/mysqld-max
+  then
+    MYSQLD=mysqld-max
+  else
+    MYSQLD=mysqld
+  fi
+fi
 
 if test ! -x $ledir/$MYSQLD
 then

sql/ha_berkeley.h

@@ -94,6 +94,9 @@ class ha_berkeley: public handler
   uint max_supported_keys()        const { return MAX_KEY-1; }
   uint extra_rec_buf_length()	 { return BDB_HIDDEN_PRIMARY_KEY_LENGTH; }
   ha_rows estimate_rows_upper_bound();
+  uint max_supported_key_length() const { return 4294967295L; }
+  uint max_supported_key_part_length() const { return 4294967295L; }
+
   const key_map *keys_to_use_for_scanning() { return &key_map_full; }
   bool has_transactions()  { return 1;}
 

sql/item_func.cc

@@ -1378,6 +1378,7 @@ my_decimal *Item_func_abs::decimal_op(my_decimal *decimal_value)
 void Item_func_abs::fix_length_and_dec()
 {
   Item_func_num1::fix_length_and_dec();
+  maybe_null= 1;
 }
 
 

sql/item_timefunc.cc

@@ -2504,6 +2504,7 @@ void Item_func_add_time::fix_length_and_dec()
   enum_field_types arg0_field_type;
   decimals=0;
   max_length=MAX_DATETIME_FULL_WIDTH*MY_CHARSET_BIN_MB_MAXLEN;
+  maybe_null= 1;
 
   /*
     The field type for the result of an Item_func_add_time function is defined

sql/spatial.cc

@@ -129,15 +129,14 @@ Geometry *Geometry::construct(Geometry_buffer *buffer,
   Geometry *result;
   char byte_order;
 
-  if (data_len < SRID_SIZE + 1 + 4)
+  if (data_len < SRID_SIZE + WKB_HEADER_SIZE)   // < 4 + (1 + 4)
     return NULL;
   byte_order= data[SRID_SIZE];
   geom_type= uint4korr(data + SRID_SIZE + 1);
-  data+= SRID_SIZE + WKB_HEADER_SIZE;
   if (!(result= create_by_typeid(buffer, (int) geom_type)))
     return NULL;
-  result->m_data= data;
-  result->m_data_end= data + (data_len - (SRID_SIZE + WKB_HEADER_SIZE));
+  result->m_data= data+ SRID_SIZE + WKB_HEADER_SIZE;
+  result->m_data_end= data + data_len;
   return result;
 }
 
@@ -739,7 +738,7 @@ uint Gis_polygon::init_from_wkb(const char *wkb, uint len, wkbByteOrder bo,
     wkb+= ls_len;
   }
 
-  return wkb - wkb_orig;
+  return (uint) (wkb - wkb_orig);
 }
 
 
@@ -1184,7 +1183,8 @@ uint Gis_multi_line_string::init_from_wkb(const char *wkb, uint len,
     return 0;
   res->q_append(n_line_strings);
   
-  for (wkb+=4; n_line_strings; n_line_strings--)
+  wkb+= 4;
+  while (n_line_strings--)
   {
     Gis_line_string ls;
     int ls_len;
@@ -1199,10 +1199,11 @@ uint Gis_multi_line_string::init_from_wkb(const char *wkb, uint len,
     if (!(ls_len= ls.init_from_wkb(wkb + WKB_HEADER_SIZE, len,
                                    (wkbByteOrder) wkb[0], res)))
       return 0;
-    wkb+= (ls_len + WKB_HEADER_SIZE);
-    len-= (ls_len + WKB_HEADER_SIZE);
+    ls_len+= WKB_HEADER_SIZE;;
+    wkb+= ls_len;
+    len-= ls_len;
   }
-  return wkb-wkb_orig;
+  return (uint) (wkb - wkb_orig);
 }
 
 
@@ -1436,7 +1437,8 @@ uint Gis_multi_polygon::init_from_wkb(const char *wkb, uint len,
     return 0;
   res->q_append(n_poly);
   
-  for (wkb+=4; n_poly; n_poly--)
+  wkb+=4;
+  while (n_poly--)
   {
     Gis_polygon p;
     int p_len;
@@ -1450,10 +1452,11 @@ uint Gis_multi_polygon::init_from_wkb(const char *wkb, uint len,
     if (!(p_len= p.init_from_wkb(wkb + WKB_HEADER_SIZE, len,
                                  (wkbByteOrder) wkb[0], res)))
       return 0;
-    wkb+= (p_len + WKB_HEADER_SIZE);
-    len-= (p_len + WKB_HEADER_SIZE);
+    p_len+= WKB_HEADER_SIZE;
+    wkb+= p_len;
+    len-= p_len;
   }
-  return wkb-wkb_orig;
+  return (uint) (wkb - wkb_orig);
 }
 
 
@@ -1733,7 +1736,8 @@ uint Gis_geometry_collection::init_from_wkb(const char *wkb, uint len,
     return 0;
   res->q_append(n_geom);
   
-  for (wkb+=4; n_geom; n_geom--)
+  wkb+= 4;
+  while (n_geom--)
   {
     Geometry_buffer buffer;
     Geometry *geom;
@@ -1752,10 +1756,11 @@ uint Gis_geometry_collection::init_from_wkb(const char *wkb, uint len,
         !(g_len= geom->init_from_wkb(wkb + WKB_HEADER_SIZE, len,
                                      (wkbByteOrder)  wkb[0], res)))
       return 0;
-    wkb+= (g_len + WKB_HEADER_SIZE);
-    len-= (g_len + WKB_HEADER_SIZE);
+    g_len+= WKB_HEADER_SIZE;
+    wkb+= g_len;
+    len-= g_len;
   }
-  return wkb-wkb_orig;
+  return (uint) (wkb - wkb_orig);
 }
 
 

sql/sql_select.cc

@@ -102,8 +102,6 @@ static COND *optimize_cond(JOIN *join, COND *conds,
                            List<TABLE_LIST> *join_list,
 			   Item::cond_result *cond_value);
 static bool resolve_nested_join (TABLE_LIST *table);
-static COND *remove_eq_conds(THD *thd, COND *cond, 
-			     Item::cond_result *cond_value);
 static bool const_expression_in_where(COND *conds,Item *item, Item **comp_item);
 static bool open_tmp_table(TABLE *table);
 static bool create_myisam_tmp_table(TABLE *table,TMP_TABLE_PARAM *param,
@@ -7474,7 +7472,7 @@ optimize_cond(JOIN *join, COND *conds, List<TABLE_LIST> *join_list,
   COND_FALSE always false	( 1 = 2 )
 */
 
-static COND *
+COND *
 remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value)
 {
   if (cond->type() == Item::COND_ITEM)

sql/sql_select.h

@@ -524,3 +524,4 @@ bool cp_buffer_from_ref(THD *thd, TABLE_REF *ref);
 bool error_if_full_join(JOIN *join);
 int report_error(TABLE *table, int error);
 int safe_index_read(JOIN_TAB *tab);
+COND *remove_eq_conds(THD *thd, COND *cond, Item::cond_result *cond_value);

sql/sql_update.cc

@@ -132,7 +132,7 @@ int mysql_update(THD *thd,
   ha_rows	updated, found;
   key_map	old_used_keys;
   TABLE		*table;
-  SQL_SELECT	*select;
+  SQL_SELECT	*select= 0;
   READ_RECORD	info;
   SELECT_LEX    *select_lex= &thd->lex->select_lex;
   bool need_reopen;
@@ -228,11 +228,19 @@ int mysql_update(THD *thd,
     DBUG_RETURN(1);				/* purecov: inspected */
   }
 
+  if (conds)
+  {
+    Item::cond_result cond_value;
+    conds= remove_eq_conds(thd, conds, &cond_value);
+    if (cond_value == Item::COND_FALSE)
+      limit= 0;                                   // Impossible WHERE
+  }
   // Don't count on usage of 'only index' when calculating which key to use
   table->used_keys.clear_all();
+  if (limit)
     select= make_select(table, 0, 0, conds, 0, &error);
-  if (error ||
-      (select && select->check_quick(thd, safe_update, limit)) || !limit)
+  if (error || !limit ||
+      (select && select->check_quick(thd, safe_update, limit)))
   {
     delete select;
     free_underlaid_joins(thd, select_lex);