[Pkg-mysql-commits] r937 - branches/sid-5.1/debian/patches

Christian Hammers ch at alioth.debian.org
Tue Oct 2 21:39:23 UTC 2007


Author: ch
Date: 2007-10-02 21:39:23 +0000 (Tue, 02 Oct 2007)
New Revision: 937

Added:
   branches/sid-5.1/debian/patches/99_TEMP_minmax.dpatch
Modified:
   branches/sid-5.1/debian/patches/00list
Log:
Added temporary patch


Modified: branches/sid-5.1/debian/patches/00list
===================================================================
--- branches/sid-5.1/debian/patches/00list	2007-10-02 20:58:10 UTC (rev 936)
+++ branches/sid-5.1/debian/patches/00list	2007-10-02 21:39:23 UTC (rev 937)
@@ -7,3 +7,4 @@
 70_upstream_debian__configure.dpatch
 71_upstream_debian__Makefile.in.dpatch
 85_ndb__staticlib.dpatch
+99_TEMP_minmax.dpatch

Added: branches/sid-5.1/debian/patches/99_TEMP_minmax.dpatch
===================================================================
--- branches/sid-5.1/debian/patches/99_TEMP_minmax.dpatch	                        (rev 0)
+++ branches/sid-5.1/debian/patches/99_TEMP_minmax.dpatch	2007-10-02 21:39:23 UTC (rev 937)
@@ -0,0 +1,2156 @@
+#! /bin/sh /usr/share/dpatch/dpatch-run
+## 99-unnamed.dpatch by  <ch at debian.org>
+##
+## All lines beginning with `## DP:' are a description of the patch.
+## DP: Temporary patch for MySQL bug http://bugs.mysql.com/bug.php?id=30866
+## DP: Using:
+## DP: 
+## DP:   vi include/my_global.h
+## DP:   
+## DP:    /* Define some useful general macros */
+## DP:   -#if !defined(max)
+## DP:   -#define max(a, b)	((a) > (b) ? (a) : (b))
+## DP:   -#define min(a, b)	((a) < (b) ? (a) : (b))
+## DP:   +#if !defined(mysql_max)
+## DP:   +#define mysql_max(a, b)      ((a) > (b) ? (a) : (b))
+## DP:   +#define mysql_min(a, b)      ((a) < (b) ? (a) : (b))
+## DP:   +static __inline long min( long a, long b ) { return ( ( a < b ) ? a : b ); }
+## DP:   +static __inline long max( long a, long b ) { return ( ( a > b ) ? a : b ); }
+## DP:    #endif
+## DP:   
+## DP:   cd client/
+## DP:   find . -type f -exec sed -i -e 's|)min(|)mysql_min(|g' -e 's|)max(|)mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|>min(|>mysql_min(|g' -e 's|>max(|>mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|<min(|<mysql_min(|g' -e 's|<max(|<mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|,min(|,mysql_min(|g' -e 's|,max(|,mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|\[min(|\[mysql_min(|g' -e 's|\[max(|\[mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|(min(|(mysql_min(|g' -e 's|(max(|(mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|+min(|+mysql_min(|g' -e 's|+max(|+mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|-min(|-mysql_min(|g' -e 's|-max(|-mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's| min(| mysql_min(|g' -e 's| max(| mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|=min(|=mysql_min(|g' -e 's|=max(|=mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|*min(|*mysql_min(|g' -e 's|*max(|*mysql_max(|g' '{}' ';' 
+## DP:   
+## DP:   cd sql/
+## DP:   find . -type f -exec sed -i -e 's|)mysql_min(|)mysql_min(|g' -e 's|)mysql_max(|)mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|>mysql_min(|>mysql_min(|g' -e 's|>mysql_max(|>mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|<mysql_min(|<mysql_min(|g' -e 's|<mysql_max(|<mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|,mysql_min(|,mysql_min(|g' -e 's|,mysql_max(|,mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|\[mysql_min(|\[mysql_min(|g' -e 's|\[mysql_max(|\[mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|(mysql_min(|(mysql_min(|g' -e 's|(mysql_max(|(mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|+mysql_min(|+mysql_min(|g' -e 's|+mysql_max(|+mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|-mysql_min(|-mysql_min(|g' -e 's|-mysql_max(|-mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's| mysql_min(| mysql_min(|g' -e 's| mysql_max(| mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|=mysql_min(|=mysql_min(|g' -e 's|=mysql_max(|=mysql_max(|g' '{}' ';'
+## DP:   find . -type f -exec sed -i -e 's|*mysql_min(|*mysql_min(|g' -e 's|*mysql_max(|*mysql_max(|g' '{}' ';' 
+
+ at DPATCH@
+
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/mysqlbinlog.cc mysql-dfsg-5.1-5.1.22rc/client/mysqlbinlog.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/mysqlbinlog.cc	2007-09-24 12:30:26.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/mysqlbinlog.cc	2007-10-02 23:35:08.000000000 +0200
+@@ -1465,7 +1465,7 @@ static int dump_local_log_entries(PRINT_
+       my_off_t length,tmp;
+       for (length= start_position_mot ; length > 0 ; length-=tmp)
+       {
+-	tmp=min(length,sizeof(buff));
++	tmp=mysql_min(length,sizeof(buff));
+ 	if (my_b_read(file, buff, (uint) tmp))
+         {
+           error= 1;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/mysql.cc mysql-dfsg-5.1-5.1.22rc/client/mysql.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/mysql.cc	2007-09-24 12:29:43.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/mysql.cc	2007-10-02 23:35:08.000000000 +0200
+@@ -2398,9 +2398,9 @@ print_table_data(MYSQL_RES *result)
+   {
+     uint length= column_names ? field->name_length : 0;
+     if (quick)
+-      length=max(length,field->length);
++      length=mysql_max(length,field->length);
+     else
+-      length=max(length,field->max_length);
++      length=mysql_max(length,field->max_length);
+     if (length < 4 && !IS_NOT_NULL(field->flags))
+       length=4;					// Room for "NULL"
+     field->max_length=length;
+@@ -2420,7 +2420,7 @@ print_table_data(MYSQL_RES *result)
+                                                   field->name,
+                                                   field->name + name_length);
+       uint display_length= field->max_length + name_length - numcells;
+-      tee_fprintf(PAGER, " %-*s |",(int) min(display_length,
++      tee_fprintf(PAGER, " %-*s |",(int) mysql_min(display_length,
+                                             MAX_COLUMN_LENGTH),
+                   field->name);
+       num_flag[off]= IS_NUM(field->type);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/mysqldump.c mysql-dfsg-5.1-5.1.22rc/client/mysqldump.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/mysqldump.c	2007-09-24 12:29:58.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/mysqldump.c	2007-10-02 23:35:08.000000000 +0200
+@@ -790,7 +790,7 @@ get_one_option(int optid, const struct m
+                                     &err_ptr, &err_len);
+       if (err_len)
+       {
+-        strmake(buff, err_ptr, min(sizeof(buff), err_len));
++        strmake(buff, err_ptr, mysql_min(sizeof(buff), err_len));
+         fprintf(stderr, "Invalid mode to --compatible: %s\n", buff);
+         exit(1);
+       }
+@@ -4389,7 +4389,7 @@ static ulong find_set(TYPELIB *lib, cons
+ 
+       for (; pos != end && *pos != ','; pos++) ;
+       var_len= (uint) (pos - start);
+-      strmake(buff, start, min(sizeof(buff), var_len));
++      strmake(buff, start, mysql_min(sizeof(buff), var_len));
+       find= find_type(buff, lib, var_len);
+       if (!find)
+       {
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/mysqltest.c mysql-dfsg-5.1-5.1.22rc/client/mysqltest.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/mysqltest.c	2007-09-24 12:30:25.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/mysqltest.c	2007-10-02 23:35:08.000000000 +0200
+@@ -4099,9 +4099,9 @@ int read_line(char *buf, int size)
+       }
+       else if ((c == '{' &&
+                 (!my_strnncoll_simple(charset_info, (const uchar*) "while", 5,
+-                                      (uchar*) buf, min(5, p - buf), 0) ||
++                                      (uchar*) buf, mysql_min(5, p - buf), 0) ||
+                  !my_strnncoll_simple(charset_info, (const uchar*) "if", 2,
+-                                      (uchar*) buf, min(2, p - buf), 0))))
++                                      (uchar*) buf, mysql_min(2, p - buf), 0))))
+       {
+         /* Only if and while commands can be terminated by { */
+         *p++= c;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/mysql_upgrade.c mysql-dfsg-5.1-5.1.22rc/client/mysql_upgrade.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/mysql_upgrade.c	2007-09-24 12:30:24.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/mysql_upgrade.c	2007-10-02 23:35:08.000000000 +0200
+@@ -401,7 +401,7 @@ static void find_tool(char *tool_path, c
+     DBUG_PRINT("enter", ("path: %s", path));
+ 
+     /* Chop off last char(since it might be a /) */
+-    path[max((strlen(path)-1), 0)]= 0;
++    path[mysql_max((strlen(path)-1), 0)]= 0;
+ 
+     /* Chop off last dir part */
+     dirname_part(path, path, &path_len);
+@@ -492,7 +492,7 @@ static int extract_variable_from_show(DY
+   if ((value_end= strchr(value_start, '\n')) == NULL)
+     return 1; /* Unexpected result */
+ 
+-  strncpy(value, value_start, min(FN_REFLEN, value_end-value_start));
++  strncpy(value, value_start, mysql_min(FN_REFLEN, value_end-value_start));
+   return 0;
+ }
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/client/sql_string.cc mysql-dfsg-5.1-5.1.22rc/client/sql_string.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/client/sql_string.cc	2007-09-24 12:29:40.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/client/sql_string.cc	2007-10-02 23:35:08.000000000 +0200
+@@ -662,7 +662,7 @@ int String::reserve(uint32 space_needed,
+ {
+   if (Alloced_length < str_length + space_needed)
+   {
+-    if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
++    if (realloc(Alloced_length + mysql_max(space_needed, grow_by) - 1))
+       return TRUE;
+   }
+   return FALSE;
+@@ -748,7 +748,7 @@ int sortcmp(const String *s,const String
+ 
+ int stringcmp(const String *s,const String *t)
+ {
+-  uint32 s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
++  uint32 s_len=s->length(),t_len=t->length(),len=mysql_min(s_len,t_len);
+   int cmp= memcmp(s->ptr(), t->ptr(), len);
+   return (cmp) ? cmp : (int) (s_len - t_len);
+ }
+@@ -765,7 +765,7 @@ String *copy_if_not_alloced(String *to,S
+   }
+   if (to->realloc(from_length))
+     return from;				// Actually an error
+-  if ((to->str_length=min(from->str_length,from_length)))
++  if ((to->str_length=mysql_min(from->str_length,from_length)))
+     memcpy(to->Ptr,from->Ptr,to->str_length);
+   to->str_charset=from->str_charset;
+   return to;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/include/my_global.h mysql-dfsg-5.1-5.1.22rc/include/my_global.h
+--- mysql-dfsg-5.1-5.1.22rc.orig/include/my_global.h	2007-09-24 12:30:24.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/include/my_global.h	2007-10-02 23:33:01.000000000 +0200
+@@ -563,9 +563,11 @@ int	__void__;
+ #endif
+ 
+ /* Define some useful general macros */
+-#if !defined(max)
+-#define max(a, b)	((a) > (b) ? (a) : (b))
+-#define min(a, b)	((a) < (b) ? (a) : (b))
++#if !defined(mysql_max)
++#define mysql_max(a, b)      ((a) > (b) ? (a) : (b))
++#define mysql_min(a, b)      ((a) < (b) ? (a) : (b))
++static __inline long min( long a, long b ) { return ( ( a < b ) ? a : b ); }
++static __inline long max( long a, long b ) { return ( ( a > b ) ? a : b ); }
+ #endif
+ 
+ #if !defined(HAVE_UINT)
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/client.c mysql-dfsg-5.1-5.1.22rc/sql/client.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/client.c	2007-09-24 12:29:33.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/client.c	2007-10-02 23:35:53.000000000 +0200
+@@ -625,7 +625,7 @@ cli_safe_read(MYSQL *mysql)
+ 	pos+= SQLSTATE_LENGTH+1;
+       }
+       (void) strmake(net->last_error,(char*) pos,
+-		     min((uint) len,(uint) sizeof(net->last_error)-1));
++		     mysql_min((uint) len,(uint) sizeof(net->last_error)-1));
+     }
+     else
+       set_mysql_error(mysql, CR_UNKNOWN_ERROR, unknown_sqlstate);
+@@ -2021,7 +2021,7 @@ CLI_MYSQL_REAL_CONNECT(MYSQL *mysql,cons
+ 	goto error;
+       }
+       memcpy(&sock_addr.sin_addr, hp->h_addr,
+-             min(sizeof(sock_addr.sin_addr), (size_t) hp->h_length));
++             mysql_min(sizeof(sock_addr.sin_addr), (size_t) hp->h_length));
+       my_gethostbyname_r_free();
+     }
+     sock_addr.sin_port = (ushort) htons((ushort) port);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/field.cc mysql-dfsg-5.1-5.1.22rc/sql/field.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/field.cc	2007-09-24 12:29:27.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/field.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -49,7 +49,7 @@ const char field_separator=',';
+ #define LONGLONG_TO_STRING_CONVERSION_BUFFER_SIZE 128
+ #define DECIMAL_TO_STRING_CONVERSION_BUFFER_SIZE 128
+ #define BLOB_PACK_LENGTH_TO_MAX_LENGH(arg) \
+-((ulong) ((LL(1) << min(arg, 4) * 8) - LL(1)))
++((ulong) ((LL(1) << mysql_min(arg, 4) * 8) - LL(1)))
+ 
+ #define ASSERT_COLUMN_MARKED_FOR_READ DBUG_ASSERT(!table || (!table->read_set || bitmap_is_set(table->read_set, field_index)))
+ #define ASSERT_COLUMN_MARKED_FOR_WRITE DBUG_ASSERT(!table || (!table->write_set || bitmap_is_set(table->write_set, field_index)))
+@@ -1980,7 +1980,7 @@ int Field_decimal::store(const char *fro
+     tmp_uint=tmp_dec+(uint)(int_digits_end-int_digits_from);
+   else if (expo_sign_char == '-') 
+   {
+-    tmp_uint=min(exponent,(uint)(int_digits_end-int_digits_from));
++    tmp_uint=mysql_min(exponent,(uint)(int_digits_end-int_digits_from));
+     frac_digits_added_zeros=exponent-tmp_uint;
+     int_digits_end -= tmp_uint;
+     frac_digits_head_end=int_digits_end+tmp_uint;
+@@ -1988,7 +1988,7 @@ int Field_decimal::store(const char *fro
+   }
+   else // (expo_sign_char=='+') 
+   {
+-    tmp_uint=min(exponent,(uint)(frac_digits_end-frac_digits_from));
++    tmp_uint=mysql_min(exponent,(uint)(frac_digits_end-frac_digits_from));
+     int_digits_added_zeros=exponent-tmp_uint;
+     int_digits_tail_from=frac_digits_from;
+     frac_digits_from=frac_digits_from+tmp_uint;
+@@ -2876,7 +2876,7 @@ String *Field_tiny::val_str(String *val_
+   ASSERT_COLUMN_MARKED_FOR_READ;
+   CHARSET_INFO *cs= &my_charset_bin;
+   uint length;
+-  uint mlength=max(field_length+1,5*cs->mbmaxlen);
++  uint mlength=mysql_max(field_length+1,5*cs->mbmaxlen);
+   val_buffer->alloc(mlength);
+   char *to=(char*) val_buffer->ptr();
+ 
+@@ -3088,7 +3088,7 @@ String *Field_short::val_str(String *val
+   ASSERT_COLUMN_MARKED_FOR_READ;
+   CHARSET_INFO *cs= &my_charset_bin;
+   uint length;
+-  uint mlength=max(field_length+1,7*cs->mbmaxlen);
++  uint mlength=mysql_max(field_length+1,7*cs->mbmaxlen);
+   val_buffer->alloc(mlength);
+   char *to=(char*) val_buffer->ptr();
+   short j;
+@@ -3305,7 +3305,7 @@ String *Field_medium::val_str(String *va
+   ASSERT_COLUMN_MARKED_FOR_READ;
+   CHARSET_INFO *cs= &my_charset_bin;
+   uint length;
+-  uint mlength=max(field_length+1,10*cs->mbmaxlen);
++  uint mlength=mysql_max(field_length+1,10*cs->mbmaxlen);
+   val_buffer->alloc(mlength);
+   char *to=(char*) val_buffer->ptr();
+   long j= unsigned_flag ? (long) uint3korr(ptr) : sint3korr(ptr);
+@@ -3524,7 +3524,7 @@ String *Field_long::val_str(String *val_
+   ASSERT_COLUMN_MARKED_FOR_READ;
+   CHARSET_INFO *cs= &my_charset_bin;
+   uint length;
+-  uint mlength=max(field_length+1,12*cs->mbmaxlen);
++  uint mlength=mysql_max(field_length+1,12*cs->mbmaxlen);
+   val_buffer->alloc(mlength);
+   char *to=(char*) val_buffer->ptr();
+   int32 j;
+@@ -3765,7 +3765,7 @@ String *Field_longlong::val_str(String *
+ {
+   CHARSET_INFO *cs= &my_charset_bin;
+   uint length;
+-  uint mlength=max(field_length+1,22*cs->mbmaxlen);
++  uint mlength=mysql_max(field_length+1,22*cs->mbmaxlen);
+   val_buffer->alloc(mlength);
+   char *to=(char*) val_buffer->ptr();
+   longlong j;
+@@ -3947,7 +3947,7 @@ String *Field_float::val_str(String *val
+ #endif
+     memcpy_fixed((uchar*) &nr,ptr,sizeof(nr));
+ 
+-  uint to_length=max(field_length,70);
++  uint to_length=mysql_max(field_length,70);
+   val_buffer->alloc(to_length);
+   char *to=(char*) val_buffer->ptr();
+ 
+@@ -4289,7 +4289,7 @@ String *Field_double::val_str(String *va
+ #endif
+     doubleget(nr,ptr);
+ 
+-  uint to_length=max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
++  uint to_length=mysql_max(field_length, DOUBLE_TO_STRING_CONVERSION_BUFFER_SIZE);
+   val_buffer->alloc(to_length);
+   char *to=(char*) val_buffer->ptr();
+ 
+@@ -6142,13 +6142,13 @@ int Field_str::store(double nr)
+   double anr= fabs(nr);
+   int neg= (nr < 0.0) ? 1 : 0;
+   if (local_char_length > 4 && local_char_length < 32 &&
+-      (anr < 1.0 ? anr > 1/(log_10[max(0,(int) local_char_length-neg-2)]) /* -2 for "0." */
++      (anr < 1.0 ? anr > 1/(log_10[mysql_max(0,(int) local_char_length-neg-2)]) /* -2 for "0." */
+        : anr < log_10[local_char_length-neg]-1))
+     use_scientific_notation= FALSE;
+ 
+   length= (uint) my_sprintf(buff, (buff, "%-.*g",
+                                    (use_scientific_notation ?
+-                                    max(0, (int)local_char_length-neg-5) :
++                                    mysql_max(0, (int)local_char_length-neg-5) :
+                                     local_char_length),
+                                    nr));
+   /*
+@@ -6357,7 +6357,7 @@ void Field_string::sql_type(String &res)
+ 
+ uchar *Field_string::pack(uchar *to, const uchar *from, uint max_length)
+ {
+-  uint length=      min(field_length,max_length);
++  uint length=      mysql_min(field_length,max_length);
+   uint local_char_length= max_length/field_charset->mbmaxlen;
+   if (length > local_char_length)
+     local_char_length= my_charpos(field_charset, from, from+length,
+@@ -7292,7 +7292,7 @@ int Field_blob::store(const char *from,u
+     from= tmpstr.ptr();
+   }
+ 
+-  new_length= min(max_data_length(), field_charset->mbmaxlen * length);
++  new_length= mysql_min(max_data_length(), field_charset->mbmaxlen * length);
+   if (value.alloc(new_length))
+     goto oom_error;
+ 
+@@ -7447,7 +7447,7 @@ int Field_blob::cmp_binary(const uchar *
+   b_length=get_length(b_ptr);
+   if (b_length > max_length)
+     b_length=max_length;
+-  diff=memcmp(a,b,min(a_length,b_length));
++  diff=memcmp(a,b,mysql_min(a_length,b_length));
+   return diff ? diff : (int) (a_length - b_length);
+ }
+ 
+@@ -8569,7 +8569,7 @@ String *Field_bit::val_str(String *val_b
+ {
+   ASSERT_COLUMN_MARKED_FOR_READ;
+   char buff[sizeof(longlong)];
+-  uint length= min(pack_length(), sizeof(longlong));
++  uint length= mysql_min(pack_length(), sizeof(longlong));
+   ulonglong bits= val_int();
+   mi_int8store(buff,bits);
+ 
+@@ -8655,7 +8655,7 @@ uint Field_bit::get_key_image(uchar *buf
+     *buff++= bits;
+     length--;
+   }
+-  uint data_length = min(length, bytes_in_rec);
++  uint data_length = mysql_min(length, bytes_in_rec);
+   memcpy(buff, ptr, data_length);
+   return data_length + 1;
+ }
+@@ -8698,7 +8698,7 @@ uchar *Field_bit::pack(uchar *to, const 
+     uchar bits= get_rec_bits(bit_ptr + (from - ptr), bit_ofs, bit_len);
+     *to++= bits;
+   }
+-  length= min(bytes_in_rec, max_length - (bit_len > 0));
++  length= mysql_min(bytes_in_rec, max_length - (bit_len > 0));
+   memcpy(to, from, length);
+   return to + length;
+ }
+@@ -9146,7 +9146,7 @@ bool Create_field::init(THD *thd, char *
+         and 19 as length of 4.1 compatible representation.
+       */
+       length= ((length+1)/2)*2; /* purecov: inspected */
+-      length= min(length, MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
++      length= mysql_min(length, MAX_DATETIME_COMPRESSED_WIDTH); /* purecov: inspected */
+     }
+     flags|= ZEROFILL_FLAG | UNSIGNED_FLAG;
+     if (fld_default_value)
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/filesort.cc mysql-dfsg-5.1-5.1.22rc/sql/filesort.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/filesort.cc	2007-09-24 12:29:58.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/filesort.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -181,7 +181,7 @@ ha_rows filesort(THD *thd, TABLE *table,
+ #ifdef CAN_TRUST_RANGE
+   if (select && select->quick && select->quick->records > 0L)
+   {
+-    records=min((ha_rows) (select->quick->records*2+EXTRA_RECORDS*2),
++    records=mysql_min((ha_rows) (select->quick->records*2+EXTRA_RECORDS*2),
+ 		table->file->stats.records)+EXTRA_RECORDS;
+     selected_records_file=0;
+   }
+@@ -203,12 +203,12 @@ ha_rows filesort(THD *thd, TABLE *table,
+     goto err;
+ 
+   memavl= thd->variables.sortbuff_size;
+-  min_sort_memory= max(MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
++  min_sort_memory= mysql_max(MIN_SORT_MEMORY, param.sort_length*MERGEBUFF2);
+   while (memavl >= min_sort_memory)
+   {
+     ulong old_memavl;
+     ulong keys= memavl/(param.rec_length+sizeof(char*));
+-    param.keys=(uint) min(records+1, keys);
++    param.keys=(uint) mysql_min(records+1, keys);
+     if ((table_sort.sort_keys=
+ 	 (uchar **) make_char_array((char **) table_sort.sort_keys,
+                                     param.keys, param.rec_length, MYF(0))))
+@@ -1049,7 +1049,7 @@ uint read_to_buffer(IO_CACHE *fromfile, 
+   register uint count;
+   uint length;
+ 
+-  if ((count=(uint) min((ha_rows) buffpek->max_keys,buffpek->count)))
++  if ((count=(uint) mysql_min((ha_rows) buffpek->max_keys,buffpek->count)))
+   {
+     if (my_pread(fromfile->file,(uchar*) buffpek->base,
+ 		 (length= rec_length*count),buffpek->file_pos,MYF_RW))
+@@ -1312,7 +1312,7 @@ int merge_buffers(SORTPARAM *param, IO_C
+          != -1 && error != 0);
+ 
+ end:
+-  lastbuff->count= min(org_max_rows-max_rows, param->max_rows);
++  lastbuff->count= mysql_min(org_max_rows-max_rows, param->max_rows);
+   lastbuff->file_pos= to_start_filepos;
+ err:
+   delete_queue(&queue);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/ha_ndbcluster.cc mysql-dfsg-5.1-5.1.22rc/sql/ha_ndbcluster.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/ha_ndbcluster.cc	2007-09-24 12:29:40.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/ha_ndbcluster.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -804,7 +804,7 @@ int ha_ndbcluster::set_ndb_value(NdbOper
+ 
+       DBUG_PRINT("value", ("set blob ptr: 0x%lx  len: %u",
+                            (long) blob_ptr, blob_len));
+-      DBUG_DUMP("value", blob_ptr, min(blob_len, 26));
++      DBUG_DUMP("value", blob_ptr, mysql_min(blob_len, 26));
+ 
+       if (set_blob_value)
+         *set_blob_value= TRUE;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/handler.h mysql-dfsg-5.1-5.1.22rc/sql/handler.h
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/handler.h	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/handler.h	2007-10-02 23:35:53.000000000 +0200
+@@ -1565,15 +1565,15 @@ public:
+   { return (HA_ERR_WRONG_COMMAND); }
+ 
+   uint max_record_length() const
+-  { return min(HA_MAX_REC_LENGTH, max_supported_record_length()); }
++  { return mysql_min(HA_MAX_REC_LENGTH, max_supported_record_length()); }
+   uint max_keys() const
+-  { return min(MAX_KEY, max_supported_keys()); }
++  { return mysql_min(MAX_KEY, max_supported_keys()); }
+   uint max_key_parts() const
+-  { return min(MAX_REF_PARTS, max_supported_key_parts()); }
++  { return mysql_min(MAX_REF_PARTS, max_supported_key_parts()); }
+   uint max_key_length() const
+-  { return min(MAX_KEY_LENGTH, max_supported_key_length()); }
++  { return mysql_min(MAX_KEY_LENGTH, max_supported_key_length()); }
+   uint max_key_part_length() const
+-  { return min(MAX_KEY_LENGTH, max_supported_key_part_length()); }
++  { return mysql_min(MAX_KEY_LENGTH, max_supported_key_part_length()); }
+ 
+   virtual uint max_supported_record_length() const { return HA_MAX_REC_LENGTH; }
+   virtual uint max_supported_keys() const { return 0; }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/ha_partition.cc mysql-dfsg-5.1-5.1.22rc/sql/ha_partition.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/ha_partition.cc	2007-09-24 12:29:43.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/ha_partition.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -2781,7 +2781,7 @@ int ha_partition::update_row(const uchar
+   /*
+     TODO:
+       set_internal_auto_increment=
+-        max(set_internal_auto_increment, new_data->auto_increment)
++        mysql_max(set_internal_auto_increment, new_data->auto_increment)
+   */
+   m_last_part= new_part_id;
+   if (new_part_id == old_part_id)
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_buff.cc mysql-dfsg-5.1-5.1.22rc/sql/item_buff.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_buff.cc	2007-09-24 12:30:11.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_buff.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -51,7 +51,7 @@ Cached_item::~Cached_item() {}
+ */
+ 
+ Cached_item_str::Cached_item_str(THD *thd, Item *arg)
+-  :item(arg), value(min(arg->max_length, thd->variables.max_sort_length))
++  :item(arg), value(mysql_min(arg->max_length, thd->variables.max_sort_length))
+ {}
+ 
+ bool Cached_item_str::cmp(void)
+@@ -60,7 +60,7 @@ bool Cached_item_str::cmp(void)
+   bool tmp;
+ 
+   if ((res=item->val_str(&tmp_value)))
+-    res->length(min(res->length(), value.alloced_length()));
++    res->length(mysql_min(res->length(), value.alloced_length()));
+   if (null_value != item->null_value)
+   {
+     if ((null_value= item->null_value))
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item.cc mysql-dfsg-5.1-5.1.22rc/sql/item.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item.cc	2007-09-24 12:29:31.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -73,7 +73,7 @@ void
+ Hybrid_type_traits_decimal::fix_length_and_dec(Item *item, Item *arg) const
+ {
+   item->decimals= arg->decimals;
+-  item->max_length= min(arg->max_length + DECIMAL_LONGLONG_DIGITS,
++  item->max_length= mysql_min(arg->max_length + DECIMAL_LONGLONG_DIGITS,
+                         DECIMAL_MAX_STR_LENGTH);
+ }
+ 
+@@ -426,9 +426,9 @@ uint Item::decimal_precision() const
+   Item_result restype= result_type();
+ 
+   if ((restype == DECIMAL_RESULT) || (restype == INT_RESULT))
+-    return min(my_decimal_length_to_precision(max_length, decimals, unsigned_flag),
++    return mysql_min(my_decimal_length_to_precision(max_length, decimals, unsigned_flag),
+                DECIMAL_MAX_PRECISION);
+-  return min(max_length, DECIMAL_MAX_PRECISION);
++  return mysql_min(max_length, DECIMAL_MAX_PRECISION);
+ }
+ 
+ 
+@@ -728,7 +728,7 @@ void Item::set_name(const char *str, uin
+ 				   &res_length);
+   }
+   else
+-    name= sql_strmake(str, (name_length= min(length,MAX_ALIAS_NAME)));
++    name= sql_strmake(str, (name_length= mysql_min(length,MAX_ALIAS_NAME)));
+ }
+ 
+ 
+@@ -4805,7 +4805,7 @@ longlong Item_hex_string::val_int()
+   // following assert is redundant, because fixed=1 assigned in constructor
+   DBUG_ASSERT(fixed == 1);
+   char *end=(char*) str_value.ptr()+str_value.length(),
+-       *ptr=end-min(str_value.length(),sizeof(longlong));
++       *ptr=end-mysql_min(str_value.length(),sizeof(longlong));
+ 
+   ulonglong value=0;
+   for (; ptr != end ; ptr++)
+@@ -6697,12 +6697,12 @@ bool Item_type_holder::join_types(THD *t
+     /* fix variable decimals which always is NOT_FIXED_DEC */
+     if (Field::result_merge_type(fld_type) == INT_RESULT)
+       item_decimals= 0;
+-    decimals= max(decimals, item_decimals);
++    decimals= mysql_max(decimals, item_decimals);
+   }
+   if (Field::result_merge_type(fld_type) == DECIMAL_RESULT)
+   {
+-    decimals= min(max(decimals, item->decimals), DECIMAL_MAX_SCALE);
+-    int precision= min(max(prev_decimal_int_part, item->decimal_int_part())
++    decimals= mysql_min(mysql_max(decimals, item->decimals), DECIMAL_MAX_SCALE);
++    int precision= mysql_min(mysql_max(prev_decimal_int_part, item->decimal_int_part())
+                        + decimals, DECIMAL_MAX_PRECISION);
+     unsigned_flag&= item->unsigned_flag;
+     max_length= my_decimal_precision_to_length(precision, decimals,
+@@ -6733,7 +6733,7 @@ bool Item_type_holder::join_types(THD *t
+      */
+     if (collation.collation != &my_charset_bin)
+     {
+-      max_length= max(old_max_chars * collation.collation->mbmaxlen,
++      max_length= mysql_max(old_max_chars * collation.collation->mbmaxlen,
+                       display_length(item) /
+                       item->collation.collation->mbmaxlen *
+                       collation.collation->mbmaxlen);
+@@ -6748,7 +6748,7 @@ bool Item_type_holder::join_types(THD *t
+     {
+       int delta1= max_length_orig - decimals_orig;
+       int delta2= item->max_length - item->decimals;
+-      max_length= max(delta1, delta2) + decimals;
++      max_length= mysql_max(delta1, delta2) + decimals;
+       if (fld_type == MYSQL_TYPE_FLOAT && max_length > FLT_DIG + 2) 
+       {
+         max_length= FLT_DIG + 6;
+@@ -6765,7 +6765,7 @@ bool Item_type_holder::join_types(THD *t
+     break;
+   }
+   default:
+-    max_length= max(max_length, display_length(item));
++    max_length= mysql_max(max_length, display_length(item));
+   };
+   maybe_null|= item->maybe_null;
+   get_full_info(item);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_cmpfunc.cc mysql-dfsg-5.1-5.1.22rc/sql/item_cmpfunc.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_cmpfunc.cc	2007-09-24 12:30:14.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_cmpfunc.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -560,7 +560,7 @@ int Arg_comparator::set_compare_func(Ite
+   {
+     if ((*a)->decimals < NOT_FIXED_DEC && (*b)->decimals < NOT_FIXED_DEC)
+     {
+-      precision= 5 / log_10[max((*a)->decimals, (*b)->decimals) + 1];
++      precision= 5 / log_10[mysql_max((*a)->decimals, (*b)->decimals) + 1];
+       if (func == &Arg_comparator::compare_real)
+         func= &Arg_comparator::compare_real_fixed;
+       else if (func == &Arg_comparator::compare_e_real)
+@@ -1032,7 +1032,7 @@ int Arg_comparator::compare_binary_strin
+       owner->null_value= 0;
+       uint res1_length= res1->length();
+       uint res2_length= res2->length();
+-      int cmp= memcmp(res1->ptr(), res2->ptr(), min(res1_length,res2_length));
++      int cmp= memcmp(res1->ptr(), res2->ptr(), mysql_min(res1_length,res2_length));
+       return cmp ? cmp : (int) (res1_length - res2_length);
+     }
+   }
+@@ -2045,11 +2045,11 @@ Item_func_ifnull::fix_length_and_dec()
+ {
+   agg_result_type(&hybrid_type, args, 2);
+   maybe_null=args[1]->maybe_null;
+-  decimals= max(args[0]->decimals, args[1]->decimals);
++  decimals= mysql_max(args[0]->decimals, args[1]->decimals);
+   max_length= (hybrid_type == DECIMAL_RESULT || hybrid_type == INT_RESULT) ?
+-    (max(args[0]->max_length - args[0]->decimals,
++    (mysql_max(args[0]->max_length - args[0]->decimals,
+          args[1]->max_length - args[1]->decimals) + decimals) :
+-    max(args[0]->max_length, args[1]->max_length);
++    mysql_max(args[0]->max_length, args[1]->max_length);
+ 
+   switch (hybrid_type) {
+   case STRING_RESULT:
+@@ -2073,8 +2073,8 @@ Item_func_ifnull::fix_length_and_dec()
+ 
+ uint Item_func_ifnull::decimal_precision() const
+ {
+-  int max_int_part=max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
+-  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
++  int max_int_part=mysql_max(args[0]->decimal_int_part(),args[1]->decimal_int_part());
++  return mysql_min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
+ }
+ 
+ 
+@@ -2203,7 +2203,7 @@ void
+ Item_func_if::fix_length_and_dec()
+ {
+   maybe_null=args[1]->maybe_null || args[2]->maybe_null;
+-  decimals= max(args[1]->decimals, args[2]->decimals);
++  decimals= mysql_max(args[1]->decimals, args[2]->decimals);
+   unsigned_flag=args[1]->unsigned_flag && args[2]->unsigned_flag;
+ 
+   enum Item_result arg1_type=args[1]->result_type();
+@@ -2244,18 +2244,18 @@ Item_func_if::fix_length_and_dec()
+     int len2= args[2]->max_length - args[2]->decimals
+       - (args[2]->unsigned_flag ? 0 : 1);
+ 
+-    max_length=max(len1, len2) + decimals + (unsigned_flag ? 0 : 1);
++    max_length=mysql_max(len1, len2) + decimals + (unsigned_flag ? 0 : 1);
+   }
+   else
+-    max_length= max(args[1]->max_length, args[2]->max_length);
++    max_length= mysql_max(args[1]->max_length, args[2]->max_length);
+ }
+ 
+ 
+ uint Item_func_if::decimal_precision() const
+ {
+-  int precision=(max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
++  int precision=(mysql_max(args[1]->decimal_int_part(),args[2]->decimal_int_part())+
+                  decimals);
+-  return min(precision, DECIMAL_MAX_PRECISION);
++  return mysql_min(precision, DECIMAL_MAX_PRECISION);
+ }
+ 
+ 
+@@ -2641,7 +2641,7 @@ uint Item_func_case::decimal_precision()
+ 
+   if (else_expr_num != -1) 
+     set_if_bigger(max_int_part, args[else_expr_num]->decimal_int_part());
+-  return min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
++  return mysql_min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
+ }
+ 
+ 
+@@ -4489,7 +4489,7 @@ void Item_func_like::turboBM_compute_suf
+       else
+       {
+ 	if (i < g)
+-	  g = i; // g = min(i, g)
++	  g = i; // g = mysql_min(i, g)
+ 	f = i;
+ 	while (g >= 0 && pattern[g] == pattern[g + plm1 - f])
+ 	  g--;
+@@ -4508,7 +4508,7 @@ void Item_func_like::turboBM_compute_suf
+       else
+       {
+ 	if (i < g)
+-	  g = i; // g = min(i, g)
++	  g = i; // g = mysql_min(i, g)
+ 	f = i;
+ 	while (g >= 0 &&
+ 	       likeconv(cs, pattern[g]) == likeconv(cs, pattern[g + plm1 - f]))
+@@ -4629,14 +4629,14 @@ bool Item_func_like::turboBM_matches(con
+       register const int v = plm1 - i;
+       turboShift = u - v;
+       bcShift    = bmBc[(uint) (uchar) text[i + j]] - plm1 + i;
+-      shift      = max(turboShift, bcShift);
+-      shift      = max(shift, bmGs[i]);
++      shift      = mysql_max(turboShift, bcShift);
++      shift      = mysql_max(shift, bmGs[i]);
+       if (shift == bmGs[i])
+-	u = min(pattern_len - shift, v);
++	u = mysql_min(pattern_len - shift, v);
+       else
+       {
+ 	if (turboShift < bcShift)
+-	  shift = max(shift, u + 1);
++	  shift = mysql_max(shift, u + 1);
+ 	u = 0;
+       }
+       j+= shift;
+@@ -4660,14 +4660,14 @@ bool Item_func_like::turboBM_matches(con
+       register const int v = plm1 - i;
+       turboShift = u - v;
+       bcShift    = bmBc[(uint) likeconv(cs, text[i + j])] - plm1 + i;
+-      shift      = max(turboShift, bcShift);
+-      shift      = max(shift, bmGs[i]);
++      shift      = mysql_max(turboShift, bcShift);
++      shift      = mysql_max(shift, bmGs[i]);
+       if (shift == bmGs[i])
+-	u = min(pattern_len - shift, v);
++	u = mysql_min(pattern_len - shift, v);
+       else
+       {
+ 	if (turboShift < bcShift)
+-	  shift = max(shift, u + 1);
++	  shift = mysql_max(shift, u + 1);
+ 	u = 0;
+       }
+       j+= shift;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_func.cc mysql-dfsg-5.1-5.1.22rc/sql/item_func.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_func.cc	2007-09-24 12:30:26.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_func.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -542,7 +542,7 @@ void Item_func::count_decimal_length()
+     set_if_bigger(max_int_part, args[i]->decimal_int_part());
+     set_if_smaller(unsigned_flag, args[i]->unsigned_flag);
+   }
+-  int precision= min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
++  int precision= mysql_min(max_int_part + decimals, DECIMAL_MAX_PRECISION);
+   max_length= my_decimal_precision_to_length(precision, decimals,
+                                              unsigned_flag);
+ }
+@@ -1152,10 +1152,10 @@ my_decimal *Item_func_plus::decimal_op(m
+ */
+ void Item_func_additive_op::result_precision()
+ {
+-  decimals= max(args[0]->decimals, args[1]->decimals);
+-  int max_int_part= max(args[0]->decimal_precision() - args[0]->decimals,
++  decimals= mysql_max(args[0]->decimals, args[1]->decimals);
++  int max_int_part= mysql_max(args[0]->decimal_precision() - args[0]->decimals,
+                         args[1]->decimal_precision() - args[1]->decimals);
+-  int precision= min(max_int_part + 1 + decimals, DECIMAL_MAX_PRECISION);
++  int precision= mysql_min(max_int_part + 1 + decimals, DECIMAL_MAX_PRECISION);
+ 
+   /* Integer operations keep unsigned_flag if one of arguments is unsigned */
+   if (result_type() == INT_RESULT)
+@@ -1263,8 +1263,8 @@ void Item_func_mul::result_precision()
+     unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
+   else
+     unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
+-  decimals= min(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE);
+-  int precision= min(args[0]->decimal_precision() + args[1]->decimal_precision(),
++  decimals= mysql_min(args[0]->decimals + args[1]->decimals, DECIMAL_MAX_SCALE);
++  int precision= mysql_min(args[0]->decimal_precision() + args[1]->decimal_precision(),
+                      DECIMAL_MAX_PRECISION);
+   max_length= my_decimal_precision_to_length(precision, decimals,unsigned_flag);
+ }
+@@ -1312,14 +1312,14 @@ my_decimal *Item_func_div::decimal_op(my
+ 
+ void Item_func_div::result_precision()
+ {
+-  uint precision=min(args[0]->decimal_precision() + prec_increment,
++  uint precision=mysql_min(args[0]->decimal_precision() + prec_increment,
+                      DECIMAL_MAX_PRECISION);
+   /* Integer operations keep unsigned_flag if one of arguments is unsigned */
+   if (result_type() == INT_RESULT)
+     unsigned_flag= args[0]->unsigned_flag | args[1]->unsigned_flag;
+   else
+     unsigned_flag= args[0]->unsigned_flag & args[1]->unsigned_flag;
+-  decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
++  decimals= mysql_min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
+   max_length= my_decimal_precision_to_length(precision, decimals,
+                                              unsigned_flag);
+ }
+@@ -1333,7 +1333,7 @@ void Item_func_div::fix_length_and_dec()
+   switch(hybrid_type) {
+   case REAL_RESULT:
+   {
+-    decimals=max(args[0]->decimals,args[1]->decimals)+prec_increment;
++    decimals=mysql_max(args[0]->decimals,args[1]->decimals)+prec_increment;
+     set_if_smaller(decimals, NOT_FIXED_DEC);
+     max_length=args[0]->max_length - args[0]->decimals + decimals;
+     uint tmp=float_length(decimals);
+@@ -1451,8 +1451,8 @@ my_decimal *Item_func_mod::decimal_op(my
+ 
+ void Item_func_mod::result_precision()
+ {
+-  decimals= max(args[0]->decimals, args[1]->decimals);
+-  max_length= max(args[0]->max_length, args[1]->max_length);
++  decimals= mysql_max(args[0]->decimals, args[1]->decimals);
++  max_length= mysql_max(args[0]->max_length, args[1]->max_length);
+ }
+ 
+ 
+@@ -1970,7 +1970,7 @@ void Item_func_round::fix_length_and_dec
+   if (args[0]->decimals == NOT_FIXED_DEC)
+   {
+     max_length= args[0]->max_length;
+-    decimals= min(decimals_to_set, NOT_FIXED_DEC);
++    decimals= mysql_min(decimals_to_set, NOT_FIXED_DEC);
+     hybrid_type= REAL_RESULT;
+     return;
+   }
+@@ -1979,7 +1979,7 @@ void Item_func_round::fix_length_and_dec
+   case REAL_RESULT:
+   case STRING_RESULT:
+     hybrid_type= REAL_RESULT;
+-    decimals= min(decimals_to_set, NOT_FIXED_DEC);
++    decimals= mysql_min(decimals_to_set, NOT_FIXED_DEC);
+     max_length= float_length(decimals);
+     break;
+   case INT_RESULT:
+@@ -2102,7 +2102,7 @@ my_decimal *Item_func_round::decimal_op(
+   longlong dec= args[1]->val_int();
+   if (dec > 0 || (dec < 0 && args[1]->unsigned_flag))
+   {
+-    dec= min((ulonglong) dec, DECIMAL_MAX_SCALE);
++    dec= mysql_min((ulonglong) dec, DECIMAL_MAX_SCALE);
+     decimals= (uint8) dec; // to get correct output
+   }
+   else if (dec < INT_MIN)
+@@ -2950,10 +2950,10 @@ udf_handler::fix_fields(THD *thd, Item_r
+       free_udf(u_d);
+       DBUG_RETURN(TRUE);
+     }
+-    func->max_length=min(initid.max_length,MAX_BLOB_WIDTH);
++    func->max_length=mysql_min(initid.max_length,MAX_BLOB_WIDTH);
+     func->maybe_null=initid.maybe_null;
+     const_item_cache=initid.const_item;
+-    func->decimals=min(initid.decimals,NOT_FIXED_DEC);
++    func->decimals=mysql_min(initid.decimals,NOT_FIXED_DEC);
+   }
+   initialized=1;
+   if (error)
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_strfunc.cc mysql-dfsg-5.1-5.1.22rc/sql/item_strfunc.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_strfunc.cc	2007-09-24 12:30:00.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_strfunc.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -1183,7 +1183,7 @@ String *Item_func_substr::val_str(String
+ 
+   length= res->charpos((int) length, (uint32) start);
+   tmp_length= res->length() - start;
+-  length= min(length, tmp_length);
++  length= mysql_min(length, tmp_length);
+ 
+   if (!start && (longlong) res->length() == length)
+     return res;
+@@ -1203,7 +1203,7 @@ void Item_func_substr::fix_length_and_de
+     if (start < 0)
+       max_length= ((uint)(-start) > max_length) ? 0 : (uint)(-start);
+     else
+-      max_length-= min((uint)(start - 1), max_length);
++      max_length-= mysql_min((uint)(start - 1), max_length);
+   }
+   if (arg_count == 3 && args[2]->const_item())
+   {
+@@ -1888,7 +1888,7 @@ String *Item_func_soundex::val_str(Strin
+   if ((null_value= args[0]->null_value))
+     return 0; /* purecov: inspected */
+ 
+-  if (tmp_value.alloc(max(res->length(), 4 * cs->mbminlen)))
++  if (tmp_value.alloc(mysql_max(res->length(), 4 * cs->mbminlen)))
+     return str; /* purecov: inspected */
+   char *to= (char *) tmp_value.ptr();
+   char *to_end= to + tmp_value.alloced_length();
+@@ -3009,11 +3009,11 @@ String* Item_func_export_set::val_str(St
+ 
+ void Item_func_export_set::fix_length_and_dec()
+ {
+-  uint length=max(args[1]->max_length,args[2]->max_length);
++  uint length=mysql_max(args[1]->max_length,args[2]->max_length);
+   uint sep_length=(arg_count > 3 ? args[3]->max_length : 1);
+   max_length=length*64+sep_length*63;
+ 
+-  if (agg_arg_charsets(collation, args+1, min(4,arg_count)-1,
++  if (agg_arg_charsets(collation, args+1, mysql_min(4,arg_count)-1,
+                        MY_COLL_ALLOW_CONV, 1))
+     return;
+ }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_sum.cc mysql-dfsg-5.1-5.1.22rc/sql/item_sum.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_sum.cc	2007-09-24 12:30:25.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_sum.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -1071,7 +1071,7 @@ Item_sum_avg_distinct::fix_length_and_de
+     AVG() will divide val by count. We need to reserve digits
+     after decimal point as the result can be fractional.
+   */
+-  decimals= min(decimals + prec_increment, NOT_FIXED_DEC);
++  decimals= mysql_min(decimals + prec_increment, NOT_FIXED_DEC);
+ }
+ 
+ 
+@@ -1134,15 +1134,15 @@ void Item_sum_avg::fix_length_and_dec()
+   if (hybrid_type == DECIMAL_RESULT)
+   {
+     int precision= args[0]->decimal_precision() + prec_increment;
+-    decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
++    decimals= mysql_min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
+     max_length= my_decimal_precision_to_length(precision, decimals,
+                                                unsigned_flag);
+-    f_precision= min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
++    f_precision= mysql_min(precision+DECIMAL_LONGLONG_DIGITS, DECIMAL_MAX_PRECISION);
+     f_scale=  args[0]->decimals;
+     dec_bin_size= my_decimal_get_binary_size(f_precision, f_scale);
+   }
+   else {
+-    decimals= min(args[0]->decimals + prec_increment, NOT_FIXED_DEC);
++    decimals= mysql_min(args[0]->decimals + prec_increment, NOT_FIXED_DEC);
+     max_length= args[0]->max_length + prec_increment;
+   }
+ }
+@@ -1326,13 +1326,13 @@ void Item_sum_variance::fix_length_and_d
+   switch (args[0]->result_type()) {
+   case REAL_RESULT:
+   case STRING_RESULT:
+-    decimals= min(args[0]->decimals + 4, NOT_FIXED_DEC);
++    decimals= mysql_min(args[0]->decimals + 4, NOT_FIXED_DEC);
+     break;
+   case INT_RESULT:
+   case DECIMAL_RESULT:
+   {
+     int precision= args[0]->decimal_precision()*2 + prec_increment;
+-    decimals= min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
++    decimals= mysql_min(args[0]->decimals + prec_increment, DECIMAL_MAX_SCALE);
+     max_length= my_decimal_precision_to_length(precision, decimals,
+                                                unsigned_flag);
+ 
+@@ -3362,7 +3362,7 @@ bool Item_func_group_concat::setup(THD *
+       duplicate values (according to the syntax of this function). If there
+       is no DISTINCT or ORDER BY clauses, we don't create this tree.
+     */
+-    init_tree(tree, (uint) min(thd->variables.max_heap_table_size,
++    init_tree(tree, (uint) mysql_min(thd->variables.max_heap_table_size,
+                                thd->variables.sortbuff_size/16), 0,
+               tree_key_length, compare_key, 0, NULL, (void*) this);
+   }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/item_timefunc.cc mysql-dfsg-5.1-5.1.22rc/sql/item_timefunc.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/item_timefunc.cc	2007-09-24 12:30:14.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/item_timefunc.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -306,14 +306,14 @@ static bool extract_date_time(DATE_TIME_
+       switch (*++ptr) {
+ 	/* Year */
+       case 'Y':
+-	tmp= (char*) val + min(4, val_len);
++	tmp= (char*) val + mysql_min(4, val_len);
+ 	l_time->year= (int) my_strtoll10(val, &tmp, &error);
+         if ((int) (tmp-val) <= 2)
+           l_time->year= year_2000_handling(l_time->year);
+ 	val= tmp;
+ 	break;
+       case 'y':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->year= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+         l_time->year= year_2000_handling(l_time->year);
+@@ -322,7 +322,7 @@ static bool extract_date_time(DATE_TIME_
+ 	/* Month */
+       case 'm':
+       case 'c':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->month= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+@@ -339,15 +339,15 @@ static bool extract_date_time(DATE_TIME_
+ 	/* Day */
+       case 'd':
+       case 'e':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->day= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+       case 'D':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->day= (int) my_strtoll10(val, &tmp, &error);
+ 	/* Skip 'st, 'nd, 'th .. */
+-	val= tmp + min((int) (val_end-tmp), 2);
++	val= tmp + mysql_min((int) (val_end-tmp), 2);
+ 	break;
+ 
+ 	/* Hour */
+@@ -358,14 +358,14 @@ static bool extract_date_time(DATE_TIME_
+ 	/* fall through */
+       case 'k':
+       case 'H':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->hour= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+ 
+ 	/* Minute */
+       case 'i':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->minute= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+@@ -373,7 +373,7 @@ static bool extract_date_time(DATE_TIME_
+ 	/* Second */
+       case 's':
+       case 'S':
+-	tmp= (char*) val + min(2, val_len);
++	tmp= (char*) val + mysql_min(2, val_len);
+ 	l_time->second= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+@@ -425,7 +425,7 @@ static bool extract_date_time(DATE_TIME_
+ 	val= tmp;
+ 	break;
+       case 'j':
+-	tmp= (char*) val + min(val_len, 3);
++	tmp= (char*) val + mysql_min(val_len, 3);
+ 	yearday= (int) my_strtoll10(val, &tmp, &error);
+ 	val= tmp;
+ 	break;
+@@ -437,7 +437,7 @@ static bool extract_date_time(DATE_TIME_
+       case 'u':
+         sunday_first_n_first_week_non_iso= (*ptr=='U' || *ptr== 'V');
+         strict_week_number= (*ptr=='V' || *ptr=='v');
+-	tmp= (char*) val + min(val_len, 2);
++	tmp= (char*) val + mysql_min(val_len, 2);
+ 	if ((week_number= (int) my_strtoll10(val, &tmp, &error)) < 0 ||
+             strict_week_number && !week_number ||
+             week_number > 53)
+@@ -449,7 +449,7 @@ static bool extract_date_time(DATE_TIME_
+       case 'X':
+       case 'x':
+         strict_week_number_year_type= (*ptr=='X');
+-        tmp= (char*) val + min(4, val_len);
++        tmp= (char*) val + mysql_min(4, val_len);
+         strict_week_number_year= (int) my_strtoll10(val, &tmp, &error);
+         val= tmp;
+         break;
+@@ -594,7 +594,7 @@ static bool extract_date_time(DATE_TIME_
+ err:
+   {
+     char buff[128];
+-    strmake(buff, val_begin, min(length, sizeof(buff)-1));
++    strmake(buff, val_begin, mysql_min(length, sizeof(buff)-1));
+     push_warning_printf(current_thd, MYSQL_ERROR::WARN_LEVEL_ERROR,
+                         ER_WRONG_VALUE_FOR_TYPE, ER(ER_WRONG_VALUE_FOR_TYPE),
+                         date_time_type, buff, "str_to_time");
+@@ -1711,7 +1711,7 @@ void Item_func_date_format::fix_length_a
+   else
+   {
+     fixed_length=0;
+-    max_length=min(arg1->max_length, MAX_BLOB_WIDTH) * 10 *
++    max_length=mysql_min(arg1->max_length, MAX_BLOB_WIDTH) * 10 *
+                    collation.collation->mbmaxlen;
+     set_if_smaller(max_length,MAX_BLOB_WIDTH);
+   }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/key.cc mysql-dfsg-5.1-5.1.22rc/sql/key.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/key.cc	2007-09-24 12:29:42.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/key.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -144,13 +144,13 @@ void key_copy(uchar *to_key, uchar *from
+         key_part->key_part_flag & HA_VAR_LENGTH_PART)
+     {
+       key_length-= HA_KEY_BLOB_LENGTH;
+-      length= min(key_length, key_part->length);
++      length= mysql_min(key_length, key_part->length);
+       key_part->field->get_key_image(to_key, length, Field::itRAW);
+       to_key+= HA_KEY_BLOB_LENGTH;
+     }
+     else
+     {
+-      length= min(key_length, key_part->length);
++      length= mysql_min(key_length, key_part->length);
+       Field *field= key_part->field;
+       CHARSET_INFO *cs= field->charset();
+       uint bytes= field->get_key_image(to_key, length, Field::itRAW);
+@@ -237,7 +237,7 @@ void key_restore(uchar *to_record, uchar
+       my_ptrdiff_t ptrdiff= to_record - field->table->record[0];
+       field->move_field_offset(ptrdiff);
+       key_length-= HA_KEY_BLOB_LENGTH;
+-      length= min(key_length, key_part->length);
++      length= mysql_min(key_length, key_part->length);
+       old_map= dbug_tmp_use_all_columns(field->table, field->table->write_set);
+       field->set_key_image(from_key, length);
+       dbug_tmp_restore_column_map(field->table->write_set, old_map);
+@@ -246,7 +246,7 @@ void key_restore(uchar *to_record, uchar
+     }
+     else
+     {
+-      length= min(key_length, key_part->length);
++      length= mysql_min(key_length, key_part->length);
+       memcpy(to_record + key_part->offset, from_key, (size_t) length);
+     }
+     from_key+= length;
+@@ -306,7 +306,7 @@ bool key_cmp_if_same(TABLE *table,const 
+ 	return 1;
+       continue;
+     }
+-    length= min((uint) (key_end-key), store_length);
++    length= mysql_min((uint) (key_end-key), store_length);
+     if (!(key_part->key_type & (FIELDFLAG_NUMBER+FIELDFLAG_BINARY+
+                                 FIELDFLAG_PACK)))
+     {
+@@ -372,7 +372,7 @@ void key_unpack(String *to,TABLE *table,
+     {
+       field->val_str(&tmp);
+       if (key_part->length < field->pack_length())
+-	tmp.length(min(tmp.length(),key_part->length));
++	tmp.length(mysql_min(tmp.length(),key_part->length));
+       to->append(tmp);
+     }
+     else
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/log.cc mysql-dfsg-5.1-5.1.22rc/sql/log.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/log.cc	2007-09-24 12:30:26.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/log.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -537,11 +537,11 @@ bool Log_to_csv_event_handler::
+     t.neg= 0;
+ 
+     /* fill in query_time field */
+-    calc_time_from_sec(&t, (long) min(query_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);
++    calc_time_from_sec(&t, (long) mysql_min(query_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);
+     if (table->field[2]->store_time(&t, MYSQL_TIMESTAMP_TIME))
+       goto err;
+     /* lock_time */
+-    calc_time_from_sec(&t, (long) min(lock_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);
++    calc_time_from_sec(&t, (long) mysql_min(lock_time, (longlong) TIME_MAX_VALUE_SECONDS), 0);
+     if (table->field[3]->store_time(&t, MYSQL_TIMESTAMP_TIME))
+       goto err;
+     /* rows_sent */
+@@ -2173,7 +2173,7 @@ const char *MYSQL_LOG::generate_name(con
+   {
+     char *p= fn_ext(log_name);
+     uint length= (uint) (p - log_name);
+-    strmake(buff, log_name, min(length, FN_REFLEN));
++    strmake(buff, log_name, mysql_min(length, FN_REFLEN));
+     return (const char*)buff;
+   }
+   return log_name;
+@@ -4285,7 +4285,7 @@ static void print_buffer_to_nt_eventlog(
+   DBUG_ENTER("print_buffer_to_nt_eventlog");
+ 
+   /* Add ending CR/LF's to string, overwrite last chars if necessary */
+-  strmov(buffptr+min(length, buffLen-5), "\r\n\r\n");
++  strmov(buffptr+mysql_min(length, buffLen-5), "\r\n\r\n");
+ 
+   setup_windows_event_source();
+   if ((event= RegisterEventSource(NULL,"MySQL")))
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/log_event.cc mysql-dfsg-5.1-5.1.22rc/sql/log_event.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/log_event.cc	2007-09-24 12:30:13.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/log_event.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -828,7 +828,7 @@ Log_event* Log_event::read_log_event(IO_
+     of 13 bytes, whereas LOG_EVENT_MINIMAL_HEADER_LEN is 19 bytes (it's
+     "minimal" over the set {MySQL >=4.0}).
+   */
+-  uint header_size= min(description_event->common_header_len,
++  uint header_size= mysql_min(description_event->common_header_len,
+                         LOG_EVENT_MINIMAL_HEADER_LEN);
+ 
+   LOCK_MUTEX;
+@@ -4172,7 +4172,7 @@ bool User_var_log_event::write(IO_CACHE*
+   char buf[UV_NAME_LEN_SIZE];
+   char buf1[UV_VAL_IS_NULL + UV_VAL_TYPE_SIZE + 
+ 	    UV_CHARSET_NUMBER_SIZE + UV_VAL_LEN_SIZE];
+-  uchar buf2[max(8, DECIMAL_MAX_FIELD_SIZE + 2)], *pos= buf2;
++  uchar buf2[mysql_max(8, DECIMAL_MAX_FIELD_SIZE + 2)], *pos= buf2;
+   uint buf1_length;
+   ulong event_length;
+ 
+@@ -5853,7 +5853,7 @@ int Rows_log_event::do_add_row_data(ucha
+     trigger false warnings.
+    */
+ #ifndef HAVE_purify
+-  DBUG_DUMP("row_data", row_data, min(length, 32));
++  DBUG_DUMP("row_data", row_data, mysql_min(length, 32));
+ #endif
+ 
+   DBUG_ASSERT(m_rows_buf <= m_rows_cur);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/mysqld.cc mysql-dfsg-5.1-5.1.22rc/sql/mysqld.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/mysqld.cc	2007-09-24 12:29:40.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/mysqld.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -2817,7 +2817,7 @@ static int init_common_variables(const c
+       can't get max_connections*5 but still got no less than was
+       requested (value of wanted_files).
+     */
+-    max_open_files= max(max(wanted_files, max_connections*5),
++    max_open_files= mysql_max(mysql_max(wanted_files, max_connections*5),
+                         open_files_limit);
+     files= my_set_max_open_files(max_open_files);
+ 
+@@ -2829,15 +2829,15 @@ static int init_common_variables(const c
+           If we have requested too much file handles than we bring
+           max_connections in supported bounds.
+         */
+-        max_connections= (ulong) min(files-10-TABLE_OPEN_CACHE_MIN*2,
++        max_connections= (ulong) mysql_min(files-10-TABLE_OPEN_CACHE_MIN*2,
+                                      max_connections);
+         /*
+           Decrease table_cache_size according to max_connections, but
+-          not below TABLE_OPEN_CACHE_MIN.  Outer min() ensures that we
++          not below TABLE_OPEN_CACHE_MIN.  Outer mysql_min() ensures that we
+           never increase table_cache_size automatically (that could
+           happen if max_connections is decreased above).
+         */
+-        table_cache_size= (ulong) min(max((files-10-max_connections)/2,
++        table_cache_size= (ulong) mysql_min(mysql_max((files-10-max_connections)/2,
+                                           TABLE_OPEN_CACHE_MIN),
+                                       table_cache_size);    
+ 	DBUG_PRINT("warning",
+@@ -4401,7 +4401,7 @@ pthread_handler_t handle_connections_soc
+ {
+   my_socket sock,new_sock;
+   uint error_count=0;
+-  uint max_used_connection= (uint) (max(ip_sock,unix_sock)+1);
++  uint max_used_connection= (uint) (mysql_max(ip_sock,unix_sock)+1);
+   fd_set readFDs,clientFDs;
+   THD *thd;
+   struct sockaddr_in cAddr;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/my_time.c mysql-dfsg-5.1-5.1.22rc/sql/my_time.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/my_time.c	2007-09-24 12:29:57.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/my_time.c	2007-10-02 23:35:53.000000000 +0200
+@@ -251,7 +251,7 @@ str_to_datetime(const char *str, uint le
+     2003-03-03 20:00:20 AM
+     20:00:20.000000 AM 03-03-2000
+   */
+-  i= max((uint) format_position[0], (uint) format_position[1]);
++  i= mysql_max((uint) format_position[0], (uint) format_position[1]);
+   set_if_bigger(i, (uint) format_position[2]);
+   allow_space= ((1 << i) | (1 << format_position[6]));
+   allow_space&= (1 | 2 | 4 | 8);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/net_serv.cc mysql-dfsg-5.1-5.1.22rc/sql/net_serv.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/net_serv.cc	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/net_serv.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -762,7 +762,7 @@ static my_bool my_net_skip_rest(NET *net
+   {
+     while (remain > 0)
+     {
+-      size_t length= min(remain, net->max_packet);
++      size_t length= mysql_min(remain, net->max_packet);
+       if (net_safe_read(net, net->buff, length, alarmed))
+ 	DBUG_RETURN(1);
+       update_statistics(thd_increment_bytes_received(length));
+@@ -936,7 +936,7 @@ my_real_read(NET *net, size_t *complen)
+ 	len=uint3korr(net->buff+net->where_b);
+ 	if (!len)				/* End of big multi-packet */
+ 	  goto end;
+-	helping = max(len,*complen) + net->where_b;
++	helping = mysql_max(len,*complen) + net->where_b;
+ 	/* The necessary size of net->buff */
+ 	if (helping >= net->max_packet)
+ 	{
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/opt_range.cc mysql-dfsg-5.1-5.1.22rc/sql/opt_range.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/opt_range.cc	2007-09-24 12:29:40.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/opt_range.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -2272,7 +2272,7 @@ int SQL_SELECT::test_quick_select(THD *t
+     group_trp= get_best_group_min_max(&param, tree);
+     if (group_trp)
+     {
+-      param.table->quick_condition_rows= min(group_trp->records,
++      param.table->quick_condition_rows= mysql_min(group_trp->records,
+                                              head->file->stats.records);
+       if (group_trp->read_cost < best_read_time)
+       {
+@@ -3737,7 +3737,7 @@ TABLE_READ_PLAN *get_best_disjunct_quick
+     {
+       imerge_trp->read_cost= imerge_cost;
+       imerge_trp->records= non_cpk_scan_records + cpk_scan_records;
+-      imerge_trp->records= min(imerge_trp->records,
++      imerge_trp->records= mysql_min(imerge_trp->records,
+                                param->table->file->stats.records);
+       imerge_trp->range_scans= range_scans;
+       imerge_trp->range_scans_end= range_scans + n_child_scans;
+@@ -7201,7 +7201,7 @@ check_quick_select(PARAM *param,uint idx
+       param->table->quick_key_parts[key]=param->max_key_part+1;
+       param->table->quick_n_ranges[key]= param->n_ranges;
+       param->table->quick_condition_rows=
+-        min(param->table->quick_condition_rows, records);
++        mysql_min(param->table->quick_condition_rows, records);
+     }
+     /*
+       Need to save quick_rows in any case as it is used when calculating
+@@ -7270,7 +7270,7 @@ check_quick_keys(PARAM *param, uint idx,
+   uchar *tmp_min_key, *tmp_max_key;
+   uint8 save_first_null_comp= param->first_null_comp;
+ 
+-  param->max_key_part=max(param->max_key_part,key_tree->part);
++  param->max_key_part=mysql_max(param->max_key_part,key_tree->part);
+   if (key_tree->left != &null_element)
+   {
+     /*
+@@ -8170,13 +8170,13 @@ int QUICK_RANGE_SELECT::reset()
+   /* Do not allocate the buffers twice. */
+   if (multi_range_length)
+   {
+-    DBUG_ASSERT(multi_range_length == min(multi_range_count, ranges.elements));
++    DBUG_ASSERT(multi_range_length == mysql_min(multi_range_count, ranges.elements));
+     DBUG_RETURN(0);
+   }
+ 
+   /* Allocate the ranges array. */
+   DBUG_ASSERT(ranges.elements);
+-  multi_range_length= min(multi_range_count, ranges.elements);
++  multi_range_length= mysql_min(multi_range_count, ranges.elements);
+   DBUG_ASSERT(multi_range_length > 0);
+   while (multi_range_length && ! (multi_range= (KEY_MULTI_RANGE*)
+                                   my_malloc(multi_range_length *
+@@ -8195,7 +8195,7 @@ int QUICK_RANGE_SELECT::reset()
+   /* Allocate the handler buffer if necessary.  */
+   if (file->ha_table_flags() & HA_NEED_READ_RANGE_BUFFER)
+   {
+-    mrange_bufsiz= min(multi_range_bufsiz,
++    mrange_bufsiz= mysql_min(multi_range_bufsiz,
+                        (QUICK_SELECT_I::records + 1)* head->s->reclength);
+ 
+     while (mrange_bufsiz &&
+@@ -8278,7 +8278,7 @@ int QUICK_RANGE_SELECT::get_next()
+         goto end;
+     }
+ 
+-    uint count= min(multi_range_length, ranges.elements -
++    uint count= mysql_min(multi_range_length, ranges.elements -
+                     (cur_range - (QUICK_RANGE**) ranges.buffer));
+     if (count == 0)
+     {
+@@ -8391,13 +8391,13 @@ int QUICK_RANGE_SELECT::get_next_prefix(
+     last_range= *(cur_range++);
+ 
+     start_key.key=    (const uchar*) last_range->min_key;
+-    start_key.length= min(last_range->min_length, prefix_length);
++    start_key.length= mysql_min(last_range->min_length, prefix_length);
+     start_key.keypart_map= last_range->min_keypart_map & keypart_map;
+     start_key.flag=   ((last_range->flag & NEAR_MIN) ? HA_READ_AFTER_KEY :
+ 		       (last_range->flag & EQ_RANGE) ?
+ 		       HA_READ_KEY_EXACT : HA_READ_KEY_OR_NEXT);
+     end_key.key=      (const uchar*) last_range->max_key;
+-    end_key.length=   min(last_range->max_length, prefix_length);
++    end_key.length=   mysql_min(last_range->max_length, prefix_length);
+     end_key.keypart_map= last_range->max_keypart_map & keypart_map;
+     /*
+       We use READ_AFTER_KEY here because if we are reading on a key
+@@ -8695,7 +8695,7 @@ bool QUICK_SELECT_DESC::test_if_null_ran
+   KEY_PART *key_part = key_parts,
+            *key_part_end= key_part+used_key_parts;
+ 
+-  for (offset= 0,  end = min(range_arg->min_length, range_arg->max_length) ;
++  for (offset= 0,  end = mysql_min(range_arg->min_length, range_arg->max_length) ;
+        offset < end && key_part != key_part_end ;
+        offset+= key_part++->store_length)
+   {
+@@ -9041,7 +9041,7 @@ cost_group_min_max(TABLE* table, KEY *in
+ 
+   TODO
+   - What happens if the query groups by the MIN/MAX field, and there is no
+-    other field as in: "select min(a) from t1 group by a" ?
++    other field as in: "select mysql_min(a) from t1 group by a" ?
+   - We assume that the general correctness of the GROUP-BY query was checked
+     before this point. Is this correct, or do we have to check it completely?
+   - Lift the limitation in condition (B3), that is, make this access method 
+@@ -9262,7 +9262,7 @@ get_best_group_min_max(PARAM *param, SEL
+         cur_group_prefix_len+= cur_part->store_length;
+         cur_used_key_parts.set_bit(key_part_nr);
+         ++cur_group_key_parts;
+-        max_key_part= max(max_key_part,key_part_nr);
++        max_key_part= mysql_max(max_key_part,key_part_nr);
+       }
+       /*
+         Check that used key parts forms a prefix of the index.
+@@ -9869,9 +9869,9 @@ void cost_group_min_max(TABLE* table, KE
+     {
+       double blocks_per_group= (double) num_blocks / (double) num_groups;
+       p_overlap= (blocks_per_group * (keys_per_subgroup - 1)) / keys_per_group;
+-      p_overlap= min(p_overlap, 1.0);
++      p_overlap= mysql_min(p_overlap, 1.0);
+     }
+-    io_cost= (double) min(num_groups * (1 + p_overlap), num_blocks);
++    io_cost= (double) mysql_min(num_groups * (1 + p_overlap), num_blocks);
+   }
+   else
+     io_cost= (keys_per_group > keys_per_block) ?
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/protocol.cc mysql-dfsg-5.1-5.1.22rc/sql/protocol.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/protocol.cc	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/protocol.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -190,7 +190,7 @@ net_printf_error(THD *thd, uint errcode,
+   length=sizeof(text_pos)-1;
+ #endif
+   length=my_vsnprintf(my_const_cast(char*) (text_pos),
+-                      min(length, sizeof(net->last_error)),
++                      mysql_min(length, sizeof(net->last_error)),
+                       format,args);
+   va_end(args);
+ 
+@@ -296,7 +296,7 @@ send_ok(THD *thd, ha_rows affected_rows,
+     pos+=2;
+ 
+     /* We can only return up to 65535 warnings in two bytes */
+-    uint tmp= min(thd->total_warn_count, 65535);
++    uint tmp= mysql_min(thd->total_warn_count, 65535);
+     int2store(pos, tmp);
+     pos+= 2;
+   }
+@@ -371,7 +371,7 @@ static void write_eof_packet(THD *thd, N
+       Don't send warn count during SP execution, as the warn_list
+       is cleared between substatements, and mysqltest gets confused
+     */
+-    uint tmp= (thd->spcont ? 0 : min(thd->total_warn_count, 65535));
++    uint tmp= (thd->spcont ? 0 : mysql_min(thd->total_warn_count, 65535));
+     buff[0]= 254;
+     int2store(buff+1, tmp);
+     /*
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_record.cc mysql-dfsg-5.1-5.1.22rc/sql/rpl_record.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_record.cc	2007-09-24 12:30:12.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/rpl_record.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -264,7 +264,7 @@ unpack_row(RELAY_LOG_INFO const *rli,
+   /*
+     throw away master's extra fields
+   */
+-  uint max_cols= min(tabledef->size(), cols->n_bits);
++  uint max_cols= mysql_min(tabledef->size(), cols->n_bits);
+   for (; i < max_cols; i++)
+   {
+     if (bitmap_is_set(cols, i))
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_rli.cc mysql-dfsg-5.1-5.1.22rc/sql/rpl_rli.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_rli.cc	2007-09-24 12:29:57.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/rpl_rli.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -645,7 +645,7 @@ int st_relay_log_info::wait_for_pos(THD*
+   ulong log_name_extension;
+   char log_name_tmp[FN_REFLEN]; //make a char[] from String
+ 
+-  strmake(log_name_tmp, log_name->ptr(), min(log_name->length(), FN_REFLEN-1));
++  strmake(log_name_tmp, log_name->ptr(), mysql_min(log_name->length(), FN_REFLEN-1));
+ 
+   char *p= fn_ext(log_name_tmp);
+   char *p_end;
+@@ -655,7 +655,7 @@ int st_relay_log_info::wait_for_pos(THD*
+     goto err;
+   }
+   // Convert 0-3 to 4
+-  log_pos= max(log_pos, BIN_LOG_HEADER_SIZE);
++  log_pos= mysql_max(log_pos, BIN_LOG_HEADER_SIZE);
+   /* p points to '.' */
+   log_name_extension= strtoul(++p, &p_end, 10);
+   /*
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_utility.cc mysql-dfsg-5.1-5.1.22rc/sql/rpl_utility.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/rpl_utility.cc	2007-09-24 12:30:25.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/rpl_utility.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -170,7 +170,7 @@ table_def::compatible_with(RELAY_LOG_INF
+   /*
+     We only check the initial columns for the tables.
+   */
+-  uint const cols_to_check= min(table->s->fields, size());
++  uint const cols_to_check= mysql_min(table->s->fields, size());
+   int error= 0;
+   RELAY_LOG_INFO const *rli= const_cast<RELAY_LOG_INFO*>(rli_arg);
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/set_var.cc mysql-dfsg-5.1-5.1.22rc/sql/set_var.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/set_var.cc	2007-09-24 12:30:00.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/set_var.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -1405,7 +1405,7 @@ bool sys_var::check_set(THD *thd, set_va
+ 					    &not_used));
+     if (error_len)
+     {
+-      strmake(buff, error, min(sizeof(buff), error_len));
++      strmake(buff, error, mysql_min(sizeof(buff), error_len));
+       goto err;
+     }
+   }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/slave.cc mysql-dfsg-5.1-5.1.22rc/sql/slave.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/slave.cc	2007-09-24 12:29:41.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/slave.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -1400,13 +1400,13 @@ bool show_master_info(THD* thd, MASTER_I
+         slave is 2. At SHOW SLAVE STATUS time, assume that the difference
+         between timestamp of slave and rli->last_master_timestamp is 0
+         (i.e. they are in the same second), then we get 0-(2-1)=-1 as a result.
+-        This confuses users, so we don't go below 0: hence the max().
++        This confuses users, so we don't go below 0: hence the mysql_max().
+ 
+         last_master_timestamp == 0 (an "impossible" timestamp 1970) is a
+         special marker to say "consider we have caught up".
+       */
+       protocol->store((longlong)(mi->rli.last_master_timestamp ?
+-                                 max(0, time_diff) : 0));
++                                 mysql_max(0, time_diff) : 0));
+     }
+     else
+     {
+@@ -1937,7 +1937,7 @@ static int exec_relay_log_event(THD* thd
+             exec_res= 0;
+             end_trans(thd, ROLLBACK);
+             /* chance for concurrent connection to get more locks */
+-            safe_sleep(thd, min(rli->trans_retries, MAX_SLAVE_RETRY_PAUSE),
++            safe_sleep(thd, mysql_min(rli->trans_retries, MAX_SLAVE_RETRY_PAUSE),
+                        (CHECK_KILLED_FUNC)sql_slave_killed, (void*)rli);
+             pthread_mutex_lock(&rli->data_lock); // because of SHOW STATUS
+             rli->trans_retries++;
+@@ -3444,7 +3444,7 @@ static IO_CACHE *reopen_relay_log(RELAY_
+     relay_log_pos       Current log pos
+     pending             Number of bytes already processed from the event
+   */
+-  rli->event_relay_log_pos= max(rli->event_relay_log_pos, BIN_LOG_HEADER_SIZE);
++  rli->event_relay_log_pos= mysql_max(rli->event_relay_log_pos, BIN_LOG_HEADER_SIZE);
+   my_b_seek(cur_log,rli->event_relay_log_pos);
+   DBUG_RETURN(cur_log);
+ }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/spatial.h mysql-dfsg-5.1-5.1.22rc/sql/spatial.h
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/spatial.h	2007-09-24 12:30:00.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/spatial.h	2007-10-02 23:35:53.000000000 +0200
+@@ -180,8 +180,8 @@ struct MBR
+     if (d != mbr->dimension() || d <= 0 || contains(mbr) || within(mbr))
+       return 0;
+ 
+-    MBR intersection(max(xmin, mbr->xmin), max(ymin, mbr->ymin),
+-                     min(xmax, mbr->xmax), min(ymax, mbr->ymax));
++    MBR intersection(mysql_max(xmin, mbr->xmin), mysql_max(ymin, mbr->ymin),
++                     mysql_min(xmax, mbr->xmax), mysql_min(ymax, mbr->ymax));
+ 
+     return (d == intersection.dimension());
+   }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sp_head.cc mysql-dfsg-5.1-5.1.22rc/sql/sp_head.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sp_head.cc	2007-09-24 12:29:42.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sp_head.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -2276,7 +2276,7 @@ sp_head::show_create_routine(THD *thd, i
+ 
+     Item_empty_string *stmt_fld=
+       new Item_empty_string(col3_caption,
+-                            max(m_defstr.length, 1024));
++                            mysql_max(m_defstr.length, 1024));
+ 
+     stmt_fld->maybe_null= TRUE;
+ 
+@@ -2478,7 +2478,7 @@ sp_head::show_routine_code(THD *thd)
+   field_list.push_back(new Item_uint("Pos", 9));
+   // 1024 is for not to confuse old clients
+   field_list.push_back(new Item_empty_string("Instruction",
+-					     max(buffer.length(), 1024)));
++					     mysql_max(buffer.length(), 1024)));
+   if (protocol->send_fields(&field_list, Protocol::SEND_NUM_ROWS |
+                                          Protocol::SEND_EOF))
+     DBUG_RETURN(1);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_acl.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_acl.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_acl.cc	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_acl.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -808,7 +808,7 @@ static ulong get_sort(uint count,...)
+         chars= 128;                             // Marker that chars existed
+       }
+     }
+-    sort= (sort << 8) + (wild_pos ? min(wild_pos, 127) : chars);
++    sort= (sort << 8) + (wild_pos ? mysql_min(wild_pos, 127) : chars);
+   }
+   va_end(args);
+   return sort;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_analyse.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_analyse.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_analyse.cc	2007-09-24 12:30:01.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_analyse.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -280,16 +280,16 @@ bool get_ev_num_info(EV_NUM_INFO *ev_inf
+   {
+     if (((longlong) info->ullval) < 0)
+       return 0; // Impossible to store as a negative number
+-    ev_info->llval =  -(longlong) max((ulonglong) -ev_info->llval, 
++    ev_info->llval =  -(longlong) mysql_max((ulonglong) -ev_info->llval, 
+ 				      info->ullval);
+-    ev_info->min_dval = (double) -max(-ev_info->min_dval, info->dval);
++    ev_info->min_dval = (double) -mysql_max(-ev_info->min_dval, info->dval);
+   }
+   else		// ulonglong is as big as bigint in MySQL
+   {
+     if ((check_ulonglong(num, info->integers) == DECIMAL_NUM))
+       return 0;
+-    ev_info->ullval = (ulonglong) max(ev_info->ullval, info->ullval);
+-    ev_info->max_dval =  (double) max(ev_info->max_dval, info->dval);
++    ev_info->ullval = (ulonglong) mysql_max(ev_info->ullval, info->ullval);
++    ev_info->max_dval =  (double) mysql_max(ev_info->max_dval, info->dval);
+   }
+   return 1;
+ } // get_ev_num_info
+@@ -1043,7 +1043,7 @@ String *field_decimal::avg(String *s, ha
+   my_decimal_div(E_DEC_FATAL_ERROR, &avg_val, sum+cur_sum, &num, prec_increment);
+   /* TODO remove this after decimal_div returns proper frac */
+   my_decimal_round(E_DEC_FATAL_ERROR, &avg_val,
+-                   min(sum[cur_sum].frac + prec_increment, DECIMAL_MAX_SCALE),
++                   mysql_min(sum[cur_sum].frac + prec_increment, DECIMAL_MAX_SCALE),
+                    FALSE,&rounded_avg);
+   my_decimal2string(E_DEC_FATAL_ERROR, &rounded_avg, 0, 0, '0', s);
+   return s;
+@@ -1068,7 +1068,7 @@ String *field_decimal::std(String *s, ha
+   my_decimal_div(E_DEC_FATAL_ERROR, &tmp, &sum2, &num, prec_increment);
+   my_decimal2double(E_DEC_FATAL_ERROR, &tmp, &std_sqr);
+   s->set_real(((double) std_sqr <= 0.0 ? 0.0 : sqrt(std_sqr)),
+-         min(item->decimals + prec_increment, NOT_FIXED_DEC), my_thd_charset);
++         mysql_min(item->decimals + prec_increment, NOT_FIXED_DEC), my_thd_charset);
+ 
+   return s;
+ }
+@@ -1185,7 +1185,7 @@ bool analyse::change_columns(List<Item> 
+   func_items[8] = new Item_proc_string("Std", 255);
+   func_items[8]->maybe_null = 1;
+   func_items[9] = new Item_proc_string("Optimal_fieldtype",
+-				       max(64, output_str_length));
++				       mysql_max(64, output_str_length));
+ 
+   for (uint i = 0; i < array_elements(func_items); i++)
+     field_list.push_back(func_items[i]);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_cache.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_cache.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_cache.cc	2007-09-24 12:30:14.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_cache.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -802,7 +802,7 @@ void query_cache_end_of_result(THD *thd)
+ 
+     last_result_block= header->result()->prev;
+     allign_size= ALIGN_SIZE(last_result_block->used);
+-    len= max(query_cache.min_allocation_unit, allign_size);
++    len= mysql_max(query_cache.min_allocation_unit, allign_size);
+     if (last_result_block->length >= query_cache.min_allocation_unit + len)
+       query_cache.split_block(last_result_block,len);
+ 
+@@ -2177,7 +2177,7 @@ Query_cache::write_block_data(ulong data
+   DBUG_ENTER("Query_cache::write_block_data");
+   DBUG_PRINT("qcache", ("data: %ld, header: %ld, all header: %ld",
+ 		      data_len, header_len, all_headers_len));
+-  Query_cache_block *block= allocate_block(max(align_len,
++  Query_cache_block *block= allocate_block(mysql_max(align_len,
+                                            min_allocation_unit),1, 0);
+   if (block != 0)
+   {
+@@ -2240,7 +2240,7 @@ Query_cache::append_result_data(Query_ca
+   ulong append_min = get_min_append_result_data_size();
+   if (last_block_free_space < data_len &&
+       append_next_free_block(last_block,
+-			     max(tail, append_min)))
++			     mysql_max(tail, append_min)))
+     last_block_free_space = last_block->length - last_block->used;
+   // If no space in last block (even after join) allocate new block
+   if (last_block_free_space < data_len)
+@@ -2272,7 +2272,7 @@ Query_cache::append_result_data(Query_ca
+   // Now finally write data to the last block
+   if (success && last_block_free_space > 0)
+   {
+-    ulong to_copy = min(data_len,last_block_free_space);
++    ulong to_copy = mysql_min(data_len,last_block_free_space);
+     DBUG_PRINT("qcache", ("use free space %lub at block 0x%lx to copy %lub",
+ 			last_block_free_space, (ulong)last_block, to_copy));
+     memcpy((uchar*) last_block + last_block->used, data, to_copy);
+@@ -2360,8 +2360,8 @@ inline ulong Query_cache::get_min_first_
+   if (queries_in_cache < QUERY_CACHE_MIN_ESTIMATED_QUERIES_NUMBER)
+     return min_result_data_size;
+   ulong avg_result = (query_cache_size - free_memory) / queries_in_cache;
+-  avg_result = min(avg_result, query_cache_limit);
+-  return max(min_result_data_size, avg_result);
++  avg_result = mysql_min(avg_result, query_cache_limit);
++  return mysql_max(min_result_data_size, avg_result);
+ }
+ 
+ inline ulong Query_cache::get_min_append_result_data_size()
+@@ -2393,7 +2393,7 @@ my_bool Query_cache::allocate_data_chain
+     ulong len= data_len + all_headers_len;
+     ulong align_len= ALIGN_SIZE(len);
+ 
+-    if (!(new_block= allocate_block(max(min_size, align_len),
++    if (!(new_block= allocate_block(mysql_max(min_size, align_len),
+ 				    min_result_data_size == 0,
+ 				    all_headers_len + min_result_data_size)))
+     {
+@@ -2402,7 +2402,7 @@ my_bool Query_cache::allocate_data_chain
+     }
+ 
+     new_block->n_tables = 0;
+-    new_block->used = min(len, new_block->length);
++    new_block->used = mysql_min(len, new_block->length);
+     new_block->type = Query_cache_block::RES_INCOMPLETE;
+     new_block->next = new_block->prev = new_block;
+     Query_cache_result *header = new_block->result();
+@@ -2838,7 +2838,7 @@ Query_cache::allocate_block(ulong len, m
+   DBUG_PRINT("qcache", ("len %lu, not less %d, min %lu",
+              len, not_less,min));
+ 
+-  if (len >= min(query_cache_size, query_cache_limit))
++  if (len >= mysql_min(query_cache_size, query_cache_limit))
+   {
+     DBUG_PRINT("qcache", ("Query cache hase only %lu memory and limit %lu",
+ 			query_cache_size, query_cache_limit));
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_class.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_class.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_class.cc	2007-09-24 12:30:24.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_class.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -342,7 +342,7 @@ char *thd_security_context(THD *thd, cha
+     if (max_query_len < 1)
+       len= thd->query_length;
+     else
+-      len= min(thd->query_length, max_query_len);
++      len= mysql_min(thd->query_length, max_query_len);
+     str.append('\n');
+     str.append(thd->query, len);
+   }
+@@ -1625,7 +1625,7 @@ bool select_export::send_data(List<Item>
+     else
+     {
+       if (fixed_row_size)
+-	used_length=min(res->length(),item->max_length);
++	used_length=mysql_min(res->length(),item->max_length);
+       else
+ 	used_length=res->length();
+       if ((result_type == STRING_RESULT || is_unsafe_field_sep) &&
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_client.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_client.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_client.cc	2007-09-24 12:29:32.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_client.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -34,7 +34,7 @@ void my_net_local_init(NET *net)
+                            (uint)global_system_variables.net_write_timeout);
+ 
+   net->retry_count=  (uint) global_system_variables.net_retry_count;
+-  net->max_packet_size= max(global_system_variables.net_buffer_length,
++  net->max_packet_size= mysql_max(global_system_variables.net_buffer_length,
+ 			    global_system_variables.max_allowed_packet);
+ #endif
+ }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_connect.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_connect.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_connect.cc	2007-09-24 12:29:32.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_connect.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -680,7 +680,7 @@ static int check_connection(THD *thd)
+       if (thd->main_security_ctx.host)
+       {
+         if (thd->main_security_ctx.host != my_localhost)
+-          thd->main_security_ctx.host[min(strlen(thd->main_security_ctx.host),
++          thd->main_security_ctx.host[mysql_min(strlen(thd->main_security_ctx.host),
+                                           HOSTNAME_LENGTH)]= 0;
+         thd->main_security_ctx.host_or_ip= thd->main_security_ctx.host;
+       }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_load.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_load.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_load.cc	2007-09-24 12:30:12.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_load.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -907,7 +907,7 @@ READ_INFO::READ_INFO(File file_par, uint
+ 
+ 
+   /* Set of a stack for unget if long terminators */
+-  uint length=max(field_term_length,line_term_length)+1;
++  uint length=mysql_max(field_term_length,line_term_length)+1;
+   set_if_bigger(length,line_start.length());
+   stack=stack_pos=(int*) sql_alloc(sizeof(int)*length);
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_parse.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_parse.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_parse.cc	2007-09-24 12:30:14.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_parse.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -5119,7 +5119,7 @@ bool check_stack_overrun(THD *thd, long 
+     return 1;
+   }
+ #ifndef DBUG_OFF
+-  max_stack_used= max(max_stack_used, stack_used);
++  max_stack_used= mysql_max(max_stack_used, stack_used);
+ #endif
+   return 0;
+ }
+@@ -6554,7 +6554,7 @@ bool check_simple_select()
+     char command[80];
+     Lex_input_stream *lip= thd->m_lip;
+     strmake(command, lip->yylval->symbol.str,
+-	    min(lip->yylval->symbol.length, sizeof(command)-1));
++	    mysql_min(lip->yylval->symbol.length, sizeof(command)-1));
+     my_error(ER_CANT_USE_OPTION_HERE, MYF(0), command);
+     return 1;
+   }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_partition.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_partition.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_partition.cc	2007-09-24 12:30:14.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_partition.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -4429,7 +4429,7 @@ that are reorganised.
+             */
+             start_part= 0;
+             end_part= new_total_partitions - (upper_2n + 1);
+-            end_part= max(lower_2n - 1, end_part);
++            end_part= mysql_max(lower_2n - 1, end_part);
+           }
+           else if (new_total_partitions <= upper_2n)
+           {
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_plugin.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_plugin.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_plugin.cc	2007-09-24 12:30:01.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_plugin.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -471,7 +471,7 @@ static st_plugin_dl *plugin_dl_add(const
+     for (i=0;
+          (old=(struct st_mysql_plugin *)(ptr+i*sizeof_st_plugin))->info;
+          i++)
+-      memcpy(cur+i, old, min(sizeof(cur[i]), sizeof_st_plugin));
++      memcpy(cur+i, old, mysql_min(sizeof(cur[i]), sizeof_st_plugin));
+ 
+     sym= cur;
+   }
+@@ -1995,7 +1995,7 @@ static int check_func_set(THD *thd, stru
+                      &error, &error_len, &not_used);
+     if (error_len)
+     {
+-      strmake(buff, error, min(sizeof(buff), error_len));
++      strmake(buff, error, mysql_min(sizeof(buff), error_len));
+       strvalue= buff;
+       goto err;
+     }
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_prepare.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_prepare.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_prepare.cc	2007-09-24 12:30:25.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_prepare.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -238,7 +238,7 @@ static bool send_prep_stmt(Prepared_stat
+   int2store(buff+5, columns);
+   int2store(buff+7, stmt->param_count);
+   buff[9]= 0;                                   // Guard against a 4.1 client
+-  tmp= min(stmt->thd->total_warn_count, 65535);
++  tmp= mysql_min(stmt->thd->total_warn_count, 65535);
+   int2store(buff+10, tmp);
+ 
+   /*
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_repl.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_repl.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_repl.cc	2007-09-24 12:29:58.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_repl.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -1191,12 +1191,12 @@ bool change_master(THD* thd, MASTER_INFO
+    {
+      /*
+        Sometimes mi->rli.master_log_pos == 0 (it happens when the SQL thread is
+-       not initialized), so we use a max().
++       not initialized), so we use a mysql_max().
+        What happens to mi->rli.master_log_pos during the initialization stages
+        of replication is not 100% clear, so we guard against problems using
+-       max().
++       mysql_max().
+       */
+-     mi->master_log_pos = max(BIN_LOG_HEADER_SIZE,
++     mi->master_log_pos = mysql_max(BIN_LOG_HEADER_SIZE,
+ 			      mi->rli.group_master_log_pos);
+      strmake(mi->master_log_name, mi->rli.group_master_log_name,
+              sizeof(mi->master_log_name)-1);
+@@ -1341,7 +1341,7 @@ bool mysql_show_binlog_events(THD* thd)
+     LEX_MASTER_INFO *lex_mi= &thd->lex->mi;
+     SELECT_LEX_UNIT *unit= &thd->lex->unit;
+     ha_rows event_count, limit_start, limit_end;
+-    my_off_t pos = max(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly
++    my_off_t pos = mysql_max(BIN_LOG_HEADER_SIZE, lex_mi->pos); // user-friendly
+     char search_file_name[FN_REFLEN], *name;
+     const char *log_file_name = lex_mi->log_file_name;
+     pthread_mutex_t *log_lock = mysql_bin_log.get_log_lock();
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_select.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_select.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_select.cc	2007-09-24 12:29:33.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_select.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -842,7 +842,7 @@ JOIN::optimize()
+   }
+ #endif
+ 
+-  /* Optimize count(*), min() and max() */
++  /* Optimize count(*), mysql_min() and mysql_max() */
+   if (tables_list && tmp_table_param.sum_func_count && ! group_list)
+   {
+     int res;
+@@ -2696,7 +2696,7 @@ make_join_statistics(JOIN *join, TABLE_L
+       This is can't be to high as otherwise we are likely to use
+       table scan.
+     */
+-    s->worst_seeks= min((double) s->found_records / 10,
++    s->worst_seeks= mysql_min((double) s->found_records / 10,
+ 			(double) s->read_time*3);
+     if (s->worst_seeks < 2.0)			// Fix for small tables
+       s->worst_seeks=2.0;
+@@ -3562,7 +3562,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_AR
+   uint	and_level,i,found_eq_constant;
+   KEY_FIELD *key_fields, *end, *field;
+   uint sz;
+-  uint m= max(select_lex->max_equal_elems,1);
++  uint m= mysql_max(select_lex->max_equal_elems,1);
+   
+   /* 
+     We use the same piece of memory to store both  KEY_FIELD 
+@@ -3585,7 +3585,7 @@ update_ref_and_keys(THD *thd, DYNAMIC_AR
+     can be not more than select_lex->max_equal_elems such 
+     substitutions.
+   */ 
+-  sz= max(sizeof(KEY_FIELD),sizeof(SARGABLE_PARAM))*
++  sz= mysql_max(sizeof(KEY_FIELD),sizeof(SARGABLE_PARAM))*
+       (((thd->lex->current_select->cond_count+1)*2 +
+ 	thd->lex->current_select->between_count)*m+1);
+   if (!(key_fields=(KEY_FIELD*)	thd->alloc(sz)))
+@@ -3738,7 +3738,7 @@ static void optimize_keyuse(JOIN *join, 
+       if (map == 1)			// Only one table
+       {
+ 	TABLE *tmp_table=join->all_tables[tablenr];
+-	keyuse->ref_table_rows= max(tmp_table->file->stats.records, 100);
++	keyuse->ref_table_rows= mysql_max(tmp_table->file->stats.records, 100);
+       }
+     }
+     /*
+@@ -4063,7 +4063,7 @@ best_access_path(JOIN      *join,
+               tmp= record_count*(tmp+keys_per_block-1)/keys_per_block;
+             }
+             else
+-              tmp= record_count*min(tmp,s->worst_seeks);
++              tmp= record_count*mysql_min(tmp,s->worst_seeks);
+           }
+         }
+         else
+@@ -4230,7 +4230,7 @@ best_access_path(JOIN      *join,
+               tmp= record_count*(tmp+keys_per_block-1)/keys_per_block;
+             }
+             else
+-              tmp= record_count*min(tmp,s->worst_seeks);
++              tmp= record_count*mysql_min(tmp,s->worst_seeks);
+           }
+           else
+             tmp= best_time;                    // Do nothing
+@@ -5133,7 +5133,7 @@ static void calc_used_field_length(THD *
+   {
+     uint blob_length=(uint) (join_tab->table->file->stats.mean_rec_length-
+ 			     (join_tab->table->s->reclength- rec_length));
+-    rec_length+=(uint) max(4,blob_length);
++    rec_length+=(uint) mysql_max(4,blob_length);
+   }
+   join_tab->used_fields=fields;
+   join_tab->used_fieldlength=rec_length;
+@@ -6500,7 +6500,7 @@ void JOIN_TAB::cleanup()
+         a correlated subquery itself, but has subqueries, we can free it
+         fully and also free JOINs of all its subqueries. The exception
+         is a subquery in SELECT list, e.g:
+-        SELECT a, (select max(b) from t1) group by c
++        SELECT a, (select mysql_max(b) from t1) group by c
+         This subquery will not be evaluated at first sweep and its value will
+         not be inserted into the temporary table. Instead, it's evaluated
+         when selecting from the temporary table. Therefore, it can't be freed
+@@ -9877,7 +9877,7 @@ create_tmp_table(THD *thd,TMP_TABLE_PARA
+     share->max_rows= ~(ha_rows) 0;
+   else
+     share->max_rows= (ha_rows) (((share->db_type() == heap_hton) ?
+-                                 min(thd->variables.tmp_table_size,
++                                 mysql_min(thd->variables.tmp_table_size,
+                                      thd->variables.max_heap_table_size) :
+                                  thd->variables.tmp_table_size) /
+ 			         share->reclength);
+@@ -13283,7 +13283,7 @@ SORT_FIELD *make_unireg_sortorder(ORDER 
+     count++;
+   if (!sortorder)
+     sortorder= (SORT_FIELD*) sql_alloc(sizeof(SORT_FIELD) *
+-                                       (max(count, *length) + 1));
++                                       (mysql_max(count, *length) + 1));
+   pos= sort= sortorder;
+ 
+   if (!pos)
+@@ -13401,7 +13401,7 @@ join_init_cache(THD *thd,JOIN_TAB *table
+   cache->length=length+blobs*sizeof(char*);
+   cache->blobs=blobs;
+   *blob_ptr=0;					/* End sequentel */
+-  size=max(thd->variables.join_buff_size, cache->length);
++  size=mysql_max(thd->variables.join_buff_size, cache->length);
+   if (!(cache->buff=(uchar*) my_malloc(size,MYF(0))))
+     DBUG_RETURN(1);				/* Don't use cache */ /* purecov: inspected */
+   cache->end=cache->buff+size;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_show.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_show.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_show.cc	2007-09-24 12:29:57.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_show.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -617,7 +617,7 @@ mysqld_show_create(THD *thd, TABLE_LIST 
+   {
+     field_list.push_back(new Item_empty_string("View",NAME_CHAR_LEN));
+     field_list.push_back(new Item_empty_string("Create View",
+-                                               max(buffer.length(),1024)));
++                                               mysql_max(buffer.length(),1024)));
+     field_list.push_back(new Item_empty_string("character_set_client",
+                                                MY_CS_NAME_SIZE));
+     field_list.push_back(new Item_empty_string("collation_connection",
+@@ -628,7 +628,7 @@ mysqld_show_create(THD *thd, TABLE_LIST 
+     field_list.push_back(new Item_empty_string("Table",NAME_CHAR_LEN));
+     // 1024 is for not to confuse old clients
+     field_list.push_back(new Item_empty_string("Create Table",
+-                                               max(buffer.length(),1024)));
++                                               mysql_max(buffer.length(),1024)));
+   }
+ 
+   if (protocol->send_fields(&field_list,
+@@ -1686,7 +1686,7 @@ void mysqld_list_processes(THD *thd,cons
+ 	    the comment in sql_class.h why this prevents crashes in possible
+             races with query_length
+           */
+-          uint length= min(max_query_length, tmp->query_length);
++          uint length= mysql_min(max_query_length, tmp->query_length);
+           thd_info->query=(char*) thd->strmake(tmp->query,length);
+         }
+         thread_infos.append(thd_info);
+@@ -1814,7 +1814,7 @@ int fill_schema_processlist(THD* thd, TA
+       if (tmp->query)
+       {
+         table->field[7]->store(tmp->query,
+-                               min(PROCESS_LIST_INFO_WIDTH,
++                               mysql_min(PROCESS_LIST_INFO_WIDTH,
+                                    tmp->query_length), cs);
+         table->field[7]->set_notnull();
+       }
+@@ -6662,7 +6662,7 @@ static bool show_create_trigger_impl(THD
+ 
+     Item_empty_string *stmt_fld=
+       new Item_empty_string("SQL Original Statement",
+-                            max(trg_sql_original_stmt.length, 1024));
++                            mysql_max(trg_sql_original_stmt.length, 1024));
+ 
+     stmt_fld->maybe_null= TRUE;
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_string.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_string.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_string.cc	2007-09-24 12:29:40.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_string.cc	2007-10-02 23:35:52.000000000 +0200
+@@ -654,7 +654,7 @@ int String::reserve(uint32 space_needed,
+ {
+   if (Alloced_length < str_length + space_needed)
+   {
+-    if (realloc(Alloced_length + max(space_needed, grow_by) - 1))
++    if (realloc(Alloced_length + mysql_max(space_needed, grow_by) - 1))
+       return TRUE;
+   }
+   return FALSE;
+@@ -740,7 +740,7 @@ int sortcmp(const String *s,const String
+ 
+ int stringcmp(const String *s,const String *t)
+ {
+-  uint32 s_len=s->length(),t_len=t->length(),len=min(s_len,t_len);
++  uint32 s_len=s->length(),t_len=t->length(),len=mysql_min(s_len,t_len);
+   int cmp= memcmp(s->ptr(), t->ptr(), len);
+   return (cmp) ? cmp : (int) (s_len - t_len);
+ }
+@@ -757,7 +757,7 @@ String *copy_if_not_alloced(String *to,S
+   }
+   if (to->realloc(from_length))
+     return from;				// Actually an error
+-  if ((to->str_length=min(from->str_length,from_length)))
++  if ((to->str_length=mysql_min(from->str_length,from_length)))
+     memcpy(to->Ptr,from->Ptr,to->str_length);
+   to->str_charset=from->str_charset;
+   return to;
+@@ -896,7 +896,7 @@ well_formed_copy_nchars(CHARSET_INFO *to
+ 
+     if (to_cs == &my_charset_bin)
+     {
+-      res= min(min(nchars, to_length), from_length);
++      res= mysql_min(mysql_min(nchars, to_length), from_length);
+       memmove(to, from, res);
+       *from_end_pos= from + res;
+       *well_formed_error_pos= NULL;
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_table.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_table.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_table.cc	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_table.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -2794,7 +2794,7 @@ mysql_prepare_create_table(THD *thd, HA_
+ 	  if ((length=column->length) > max_key_length ||
+ 	      length > file->max_key_part_length())
+ 	  {
+-	    length=min(max_key_length, file->max_key_part_length());
++	    length=mysql_min(max_key_length, file->max_key_part_length());
+ 	    if (key->type == Key::MULTIPLE)
+ 	    {
+ 	      /* not a critical problem */
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_yacc.cc mysql-dfsg-5.1-5.1.22rc/sql/sql_yacc.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_yacc.cc	2007-09-24 13:08:02.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_yacc.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -14925,7 +14925,7 @@ yyreduce:
+               from 0" (4 in fact), unspecified means "don't change the position
+               (keep the preceding value)").
+            */
+-           Lex->mi.pos = max(BIN_LOG_HEADER_SIZE, Lex->mi.pos);
++           Lex->mi.pos = mysql_max(BIN_LOG_HEADER_SIZE, Lex->mi.pos);
+          }
+     break;
+ 
+@@ -14941,7 +14941,7 @@ yyreduce:
+     {
+            Lex->mi.relay_log_pos = (yyvsp[0].ulong_num);
+            /* Adjust if < BIN_LOG_HEADER_SIZE (same comment as Lex->mi.pos) */
+-           Lex->mi.relay_log_pos = max(BIN_LOG_HEADER_SIZE, Lex->mi.relay_log_pos);
++           Lex->mi.relay_log_pos = mysql_max(BIN_LOG_HEADER_SIZE, Lex->mi.relay_log_pos);
+          }
+     break;
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_yacc.yy mysql-dfsg-5.1-5.1.22rc/sql/sql_yacc.yy
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/sql_yacc.yy	2007-09-24 12:30:00.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/sql_yacc.yy	2007-10-02 23:35:53.000000000 +0200
+@@ -1546,7 +1546,7 @@ master_file_def:
+               from 0" (4 in fact), unspecified means "don't change the position
+               (keep the preceding value)").
+            */
+-           Lex->mi.pos = max(BIN_LOG_HEADER_SIZE, Lex->mi.pos);
++           Lex->mi.pos = mysql_max(BIN_LOG_HEADER_SIZE, Lex->mi.pos);
+          }
+        | RELAY_LOG_FILE_SYM EQ TEXT_STRING_sys
+          {
+@@ -1556,7 +1556,7 @@ master_file_def:
+          {
+            Lex->mi.relay_log_pos = $3;
+            /* Adjust if < BIN_LOG_HEADER_SIZE (same comment as Lex->mi.pos) */
+-           Lex->mi.relay_log_pos = max(BIN_LOG_HEADER_SIZE, Lex->mi.relay_log_pos);
++           Lex->mi.relay_log_pos = mysql_max(BIN_LOG_HEADER_SIZE, Lex->mi.relay_log_pos);
+          }
+        ;
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/stacktrace.c mysql-dfsg-5.1-5.1.22rc/sql/stacktrace.c
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/stacktrace.c	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/stacktrace.c	2007-10-02 23:35:54.000000000 +0200
+@@ -131,7 +131,7 @@ terribly wrong...\n");
+ 
+   if (!stack_bottom || (uchar*) stack_bottom > (uchar*) &fp)
+   {
+-    ulong tmp= min(0x10000,thread_stack);
++    ulong tmp= mysql_min(0x10000,thread_stack);
+     /* Assume that the stack starts at the previous even 65K */
+     stack_bottom= (uchar*) (((ulong) &fp + tmp) &
+ 			  ~(ulong) 0xFFFF);
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/thr_malloc.cc mysql-dfsg-5.1-5.1.22rc/sql/thr_malloc.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/thr_malloc.cc	2007-09-24 12:29:33.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/thr_malloc.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -102,7 +102,7 @@ char *sql_strmake_with_convert(const cha
+   if ((from_cs == &my_charset_bin) || (to_cs == &my_charset_bin))
+   {
+     // Safety if to_cs->mbmaxlen > 0
+-    new_length= min(arg_length, max_res_length);
++    new_length= mysql_min(arg_length, max_res_length);
+     memcpy(pos, str, new_length);
+   }
+   else
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/tztime.cc mysql-dfsg-5.1-5.1.22rc/sql/tztime.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/tztime.cc	2007-09-24 12:30:26.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/tztime.cc	2007-10-02 23:35:54.000000000 +0200
+@@ -167,7 +167,7 @@ tz_load(const char *name, TIME_ZONE_INFO
+       uchar buf[sizeof(struct tzhead) + sizeof(my_time_t) * TZ_MAX_TIMES +
+                 TZ_MAX_TIMES + sizeof(TRAN_TYPE_INFO) * TZ_MAX_TYPES +
+ #ifdef ABBR_ARE_USED
+-               max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1))) +
++               mysql_max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1))) +
+ #endif
+                sizeof(LS_INFO) * TZ_MAX_LEAPS];
+     } u;
+@@ -396,7 +396,7 @@ prepare_tz_info(TIME_ZONE_INFO *sp, MEM_
+       Let us choose end_t as point before next time type change or leap
+       second correction.
+     */
+-    end_t= min((next_trans_idx < sp->timecnt) ? sp->ats[next_trans_idx] - 1:
++    end_t= mysql_min((next_trans_idx < sp->timecnt) ? sp->ats[next_trans_idx] - 1:
+                                                 MY_TIME_T_MAX,
+                (next_leap_idx < sp->leapcnt) ?
+                  sp->lsis[next_leap_idx].ls_trans - 1: MY_TIME_T_MAX);
+@@ -1819,7 +1819,7 @@ tz_load_from_open_tables(const String *t
+   uchar types[TZ_MAX_TIMES];
+   TRAN_TYPE_INFO ttis[TZ_MAX_TYPES];
+ #ifdef ABBR_ARE_USED
+-  char chars[max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
++  char chars[mysql_max(TZ_MAX_CHARS + 1, (2 * (MY_TZNAME_MAX + 1)))];
+ #endif
+   DBUG_ENTER("tz_load_from_open_tables");
+ 
+diff -Nurp mysql-dfsg-5.1-5.1.22rc.orig/sql/unireg.cc mysql-dfsg-5.1-5.1.22rc/sql/unireg.cc
+--- mysql-dfsg-5.1-5.1.22rc.orig/sql/unireg.cc	2007-09-24 12:29:59.000000000 +0200
++++ mysql-dfsg-5.1-5.1.22rc/sql/unireg.cc	2007-10-02 23:35:53.000000000 +0200
+@@ -435,7 +435,7 @@ static uchar *pack_screens(List<Create_f
+     }
+     cfield->row=(uint8) row;
+     cfield->col=(uint8) (length+1);
+-    cfield->sc_length=(uint8) min(cfield->length,cols-(length+2));
++    cfield->sc_length=(uint8) mysql_min(cfield->length,cols-(length+2));
+   }
+   length=(uint) (pos-start_screen);
+   int2store(start_screen,length);
+@@ -655,7 +655,7 @@ static bool pack_header(uchar *forminfo,
+     DBUG_RETURN(1);
+   }
+   /* Hack to avoid bugs with small static rows in MySQL */
+-  reclength=max(file->min_record_length(table_options),reclength);
++  reclength=mysql_max(file->min_record_length(table_options),reclength);
+   if (info_length+(ulong) create_fields.elements*FCOMP+288+
+       n_length+int_length+com_length > 65535L || int_count > 255)
+   {




More information about the Pkg-mysql-commits mailing list