Merge mysql.com:/home/pz/mysql/mysql-4.0-root

into mysql.com:/home/pz/mysql/mysql-4.0


Docs/manual.texi:
  Auto merged
sql/item_func.cc:
  Auto merged
sql/item_func.h:
  Auto merged
sql/lex.h:
  Auto merged
sql/sql_yacc.yy:
  Auto merged

4 files changed, 147 insertions, 47 deletions

diff --git a/mysys/default.c b/mysys/default.c
index 12d7d2e4ed0..fdeeabf83eb 100644
--- a/mysys/default.c
+++ b/mysys/default.c
@@ -82,7 +82,7 @@ void load_defaults(const char *conf_file, const char **groups,
   char *ptr,**res;
   DBUG_ENTER("load_defaults");
 
-  init_alloc_root(&alloc,128,0);
+  init_alloc_root(&alloc,512,0);
   if (*argc >= 2 && !strcmp(argv[0][1],"--no-defaults"))
   {
     /* remove the --no-defaults argument and return only the other arguments */
diff --git a/mysys/mf_iocache.c b/mysys/mf_iocache.c
index b141e341016..b6e721cbd57 100644
--- a/mysys/mf_iocache.c
+++ b/mysys/mf_iocache.c
@@ -547,7 +547,7 @@ int _my_b_read_r(register IO_CACHE *info, byte *Buffer, uint Count)
       info->error=(int) read_len;
       DBUG_RETURN(1);
     }
-    cnt=(len > Count) ? (int) Count : len;
+    cnt=((uint) len > Count) ? (int) Count : len;
     memcpy(Buffer,info->read_pos, (size_t)cnt);
     Count -=cnt;
     Buffer+=cnt;
diff --git a/mysys/mf_keycache.c b/mysys/mf_keycache.c
index 2ddf13bfa1f..5a573bff0f7 100644
--- a/mysys/mf_keycache.c
+++ b/mysys/mf_keycache.c
@@ -53,6 +53,7 @@ typedef struct sec_link {
 
 
 static SEC_LINK *find_key_block(int file,my_off_t filepos,int *error);
+static int flush_all_key_blocks();
 
 	/* static variables in this file */
 static SEC_LINK *_my_block_root,**_my_hash_root,
@@ -76,11 +77,9 @@ static my_bool	_my_printed;
 	/* Returns blocks in use */
 	/* ARGSUSED */
 
-int init_key_cache(ulong use_mem,
-		   ulong leave_this_much_mem __attribute__((unused)))
+int init_key_cache(ulong use_mem)
 {
   uint blocks,length;
-  byte *extra_mem=0;
   DBUG_ENTER("init_key_cache");
 
   if (key_cache_inited && _my_disk_blocks > 0)
@@ -105,10 +104,6 @@ int init_key_cache(ulong use_mem,
   /* No use to have very few blocks */
   if (blocks >= 8 && _my_disk_blocks < 0)
   {
-#if !defined(HAVE_ALLOCA) && !defined(THREAD)
-    if ((extra_mem=my_malloc((uint) leave_this_much_mem,MYF(0))) == 0)
-      goto err;
-#endif
     for (;;)
     {
       /* Set my_hash_blocks to the next bigger 2 power */
@@ -138,21 +133,48 @@ int init_key_cache(ulong use_mem,
     DBUG_PRINT("exit",("disk_blocks: %d  block_root: %lx  _my_hash_blocks: %d  hash_root: %lx",
 		       _my_disk_blocks,_my_block_root,_my_hash_blocks,
 		       _my_hash_root));
-#if !defined(HAVE_ALLOCA) && !defined(THREAD)
-    my_free(extra_mem,MYF(0));
-#endif
   }
   bzero((gptr) changed_blocks,sizeof(changed_blocks[0])*CHANGED_BLOCKS_HASH);
   bzero((gptr) file_blocks,sizeof(file_blocks[0])*CHANGED_BLOCKS_HASH);
   DBUG_RETURN((int) blocks);
+
 err:
-  if (extra_mem) /* purecov: inspected */
-    my_free(extra_mem,MYF(0));
   my_errno=ENOMEM;
   DBUG_RETURN(0);
 } /* init_key_cache */
 
 
+/*
+  Resize the key cache
+
+  SYNOPSIS
+    resize_key_cache()
+    use_mem		Bytes to use for new key cache
+
+  RETURN VALUES
+    0	Error
+    #	number of blocks in key cache
+*/
+
+
+int resize_key_cache(ulong use_mem)
+{
+  int block;
+  pthread_mutex_lock(&THR_LOCK_keycache);
+  if (flush_all_key_blocks())
+  {
+    /* TODO: If this happens, we should write a warning in the log file ! */
+    pthread_mutex_unlock(&THR_LOCK_keycache);
+    return 0;
+  }
+  end_key_cache();
+  /* The following will work even if memory is 0 */
+  block=init_key_cache(use_mem);
+  pthread_mutex_unlock(&THR_LOCK_keycache);  
+  return block;
+}
+
+
 	/* Remove key_cache from memory */
 
 void end_key_cache(void)
@@ -264,6 +286,11 @@ byte *key_cache_read(File file, my_off_t filepos, byte *buff, uint length,
     byte *start=buff;
     uint read_length;
     pthread_mutex_lock(&THR_LOCK_keycache);
+    if (_my_disk_blocks <= 0)			/* Resize failed */
+    {
+      pthread_mutex_unlock(&THR_LOCK_keycache);
+      goto no_key_cache;
+    }
     do
     {
       _my_cache_r_requests++;
@@ -300,6 +327,8 @@ byte *key_cache_read(File file, my_off_t filepos, byte *buff, uint length,
     pthread_mutex_unlock(&THR_LOCK_keycache);
     DBUG_RETURN(start);
   }
+
+no_key_cache:
   _my_cache_r_requests++;
   _my_cache_read++;
   if (my_pread(file,(byte*) buff,length,filepos,MYF(MY_NABP)))
@@ -336,6 +365,12 @@ int key_cache_write(File file, my_off_t filepos, byte *buff, uint length,
   {						/* We have key_cacheing */
     uint read_length;
     pthread_mutex_lock(&THR_LOCK_keycache);
+    if (_my_disk_blocks <= 0)			/* If resize failed */
+    {
+      pthread_mutex_unlock(&THR_LOCK_keycache);
+      goto no_key_cache;
+    }
+
     _my_cache_w_requests++;
     do
     {
@@ -359,8 +394,11 @@ int key_cache_write(File file, my_off_t filepos, byte *buff, uint length,
     } while ((length-= read_length));
     error=0;
     pthread_mutex_unlock(&THR_LOCK_keycache);
+    goto end;
   }
-  else if (dont_write)
+
+no_key_cache:
+  if (dont_write)
   {						/* We must write, no cache */
     _my_cache_w_requests++;
     _my_cache_write++;
@@ -368,6 +406,7 @@ int key_cache_write(File file, my_off_t filepos, byte *buff, uint length,
 		  MYF(MY_NABP | MY_WAIT_IF_FULL)))
       error=1;
   }
+
 end:
 #if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
   DBUG_EXECUTE("check_keycache",test_key_cache("end of key_cache_write",1););
@@ -507,6 +546,7 @@ static int cmp_sec_link(SEC_LINK **a, SEC_LINK **b)
 	  ((*a)->diskpos > (*b)->diskpos) ? 1 : 0);
 }
 
+
 static int flush_cached_blocks(File file, SEC_LINK **cache, uint count)
 {
   uint last_errno=0;
@@ -525,25 +565,23 @@ static int flush_cached_blocks(File file, SEC_LINK **cache, uint count)
 }
 
 
-int flush_key_blocks(File file, enum flush_type type)
+static int flush_key_blocks_int(File file, enum flush_type type)
 {
   int error=0,last_errno=0;
   uint count=0;
   SEC_LINK *cache_buff[FLUSH_CACHE],**cache,**pos,**end;
   SEC_LINK *used,*next;
-  DBUG_ENTER("flush_key_blocks");
+  DBUG_ENTER("flush_key_blocks_int");
   DBUG_PRINT("enter",("file: %d  blocks_used: %d  blocks_changed: %d",
 		      file,_my_blocks_used,_my_blocks_changed));
 
-  pthread_mutex_lock(&THR_LOCK_keycache);
-
-#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
-  DBUG_EXECUTE("check_keycache",test_key_cache("start of flush_key_blocks",0););
-#endif
   cache=cache_buff;				/* If no key cache */
   if (_my_disk_blocks > 0 &&
       (!my_disable_flush_key_blocks || type != FLUSH_KEEP))
   {
+#if !defined(DBUG_OFF) && defined(EXTRA_DEBUG)
+    DBUG_EXECUTE("check_keycache",test_key_cache("start of flush_key_blocks",0););
+#endif
     if (type != FLUSH_IGNORE_CHANGED)
     {
       /* Count how many key blocks we have to cache to be able to
@@ -614,22 +652,69 @@ int flush_key_blocks(File file, enum flush_type type)
 	  free_block(used);
       }
     }
-  }
 #ifndef DBUG_OFF
-  DBUG_EXECUTE("check_keycache",test_key_cache("end of flush_key_blocks",0););
+    DBUG_EXECUTE("check_keycache",test_key_cache("end of flush_key_blocks",0););
 #endif
-  pthread_mutex_unlock(&THR_LOCK_keycache);
+  }
   if (cache != cache_buff)
     my_free((gptr) cache,MYF(0));
   if (last_errno)
     errno=last_errno;				/* Return first error */
   DBUG_RETURN(last_errno != 0);
-} /* flush_key_blocks */
+}
+
+
+/*
+  Flush all blocks for a specific file to disk
+
+  SYNOPSIS
+    flush_all_key_blocks()
+    file	File descriptor
+    type	Type of flush operation
+
+  RETURN VALUES
+    0		Ok
+    1		Error
+*/
+
+int flush_key_blocks(File file, enum flush_type type)
+{
+  int res;
+  pthread_mutex_lock(&THR_LOCK_keycache);
+  res=flush_key_blocks_int(file, type);
+  pthread_mutex_unlock(&THR_LOCK_keycache);
+  return res;
+}
+
+
+/*
+  Flush all blocks in the key cache to disk
+
+  SYNOPSIS
+    flush_all_key_blocks()
+
+  NOTE
+    We must have a lock on THR_LOCK_keycache before calling this function
+
+  RETURN VALUES
+    0		Ok
+    1		Error
+*/
+
+
+static int flush_all_key_blocks()
+{
+  int error=0;
+  while (_my_blocks_changed > 0)
+    if (flush_key_blocks_int(_my_used_first->file, FLUSH_RELEASE))
+      error=1;
+  return error;
+}
 
 
 #ifndef DBUG_OFF
 
-	/* Test if disk-cachee is ok */
+	/* Test if disk-cache is ok */
 
 static void test_key_cache(const char *where, my_bool lock)
 {
@@ -638,7 +723,14 @@ static void test_key_cache(const char *where, my_bool lock)
   SEC_LINK *pos,**prev;
 
   if (lock)
+  {
     pthread_mutex_lock(&THR_LOCK_keycache);
+    if (_my_disk_blocks <= 0)			/* No active key cache */
+    {
+      pthread_mutex_unlock(&THR_LOCK_keycache);
+      return;
+    }
+  }
   found=error=0;
   for (i= 0 ; i < _my_hash_blocks ; i++)
   {
diff --git a/mysys/my_getopt.c b/mysys/my_getopt.c
index b0eb8a8b2e5..436e557c914 100644
--- a/mysys/my_getopt.c
+++ b/mysys/my_getopt.c
@@ -25,7 +25,8 @@
 static int findopt(char *optpat, uint length,
 		   const struct my_option **opt_res,
 		   char **ffname);
-static my_bool compare_strings(register const char *s, register const char *t,
+my_bool getopt_compare_strings(const char *s,
+			       const char *t,
 			       uint length);
 static longlong getopt_ll(char *arg, const struct my_option *optp, int *err);
 static ulonglong getopt_ull(char *arg, const struct my_option *optp,
@@ -116,7 +117,7 @@ int handle_options(int *argc, char ***argv,
 	    (*argc)--;
 	  }
 	}
-	else if (!compare_strings(cur_arg, "-set-variable", 13))
+	else if (!getopt_compare_strings(cur_arg, "-set-variable", 13))
 	{
 	  must_be_var= 1;
 	  if (cur_arg[13] == '=')
@@ -182,8 +183,8 @@ int handle_options(int *argc, char ***argv,
 	      must_be_var= 1; /* option is followed by an argument */
 	    for (i= 0; special_opt_prefix[i]; i++)
 	    {
-	      if (!compare_strings(special_opt_prefix[i], cur_arg,
-				   special_opt_prefix_lengths[i]) &&
+	      if (!getopt_compare_strings(special_opt_prefix[i], cur_arg,
+					  special_opt_prefix_lengths[i]) &&
 		  cur_arg[special_opt_prefix_lengths[i]] == '-')
 	      {
 		/*
@@ -481,21 +482,21 @@ static int setval (const struct my_option *opts, char *argument,
   the name in ffname argument
 */
 
-static int findopt (char *optpat, uint length,
-		    const struct my_option **opt_res,
-		    char **ffname)
+static int findopt(char *optpat, uint length,
+		   const struct my_option **opt_res,
+		   char **ffname)
 {
   int count;
   struct my_option *opt= (struct my_option *) *opt_res;
 
   for (count= 0; opt->name; opt++)
   {
-    if (!compare_strings(opt->name, optpat, length)) /* match found */
+    if (!getopt_compare_strings(opt->name, optpat, length)) /* match found */
     {
       (*opt_res)= opt;
       if (!count)
-	*ffname= (char *) opt->name;     /* we only need to know one prev */
-      if (length == strlen(opt->name))   /* exact match */
+	*ffname= (char *) opt->name;	/* We only need to know one prev */
+      if (!opt->name[length])		/* Exact match */
 	return 1;
       count++;
     }
@@ -511,7 +512,7 @@ static int findopt (char *optpat, uint length,
   2.) Returns -1 if strings differ, 0 if they are equal
 */
 
-static my_bool compare_strings(register const char *s, register const char *t,
+my_bool getopt_compare_strings(register const char *s, register const char *t,
 			       uint length)
 {
   char const *end= s + length;
@@ -565,7 +566,7 @@ static longlong eval_num_suffix (char *argument, int *error, char *option_name)
   In case of an error, set error value in *err.
 */
 
-static longlong getopt_ll (char *arg, const struct my_option *optp, int *err)
+longlong getopt_ll (char *arg, const struct my_option *optp, int *err)
 {
   longlong num;
   
@@ -594,16 +595,23 @@ static ulonglong getopt_ull (char *arg, const struct my_option *optp, int *err)
   ulonglong num;
 
   num= eval_num_suffix(arg, err, (char*) optp->name);  
+  return getopt_ull_limit_value(num, optp);
+}
+
+
+ulonglong getopt_ull_limit_value(ulonglong num, const struct my_option *optp)
+{
+  if ((ulonglong) num > (ulonglong) (ulong) optp->max_value &&
+      optp->max_value) /* if max value is not set -> no upper limit */
+    num= (ulonglong) (ulong) optp->max_value;
+  if (optp->block_size > 1)
+  {
+    num/= (ulonglong) optp->block_size;
+    num*= (ulonglong) optp->block_size;
+  }
   if (num < (ulonglong) optp->min_value)
     num= (ulonglong) optp->min_value;
-  else if (num > 0 && (ulonglong) num > (ulonglong) (ulong) optp->max_value
-	   && optp->max_value) /* if max value is not set -> no upper limit */
-    num= (ulonglong) (ulong) optp->max_value;
-  num= ((num - (ulonglong) optp->sub_size) / (optp->block_size ?
-					      (ulonglong) optp->block_size :
-					      1L));
-  return (ulonglong) (num * (optp->block_size ? (ulonglong) optp->block_size :
-			     1L));
+  return num;
 }
 
 /*