This patch cleans up two tests which were a bit fragile from other failing...

This patch cleans up two tests which were a bit fragile from other failing tests. It also removes some variables associated with removed RAID support.


BitKeeper/deleted/.del-raid.h~2d2503a66b128ac6:
  Delete: include/raid.h
BitKeeper/deleted/.del-raid.cc~488f5fa6538394e1:
  Delete: mysys/raid.cc
BitKeeper/deleted/.del-raid2.c~fe7aea5fb4b9748c:
  Delete: mysys/raid2.c
include/Makefile.am:
  Removing raid
include/my_sys.h:
  Removing Raid
include/myisam.h:
  Removing raid
mysql-test/r/case.result:
  Cleaned up incomming tables
mysql-test/r/mysqlcheck.result:
  new results
mysql-test/t/case.test:
  Cleaned up test
mysql-test/t/mysqlcheck.test:
  Cleaned up two tests.
mysys/Makefile.am:
  Removed raid
mysys/my_static.c:
  Removed raid
storage/myisam/mi_check.c:
  Removed raid
storage/myisam/mi_info.c:
  Removed raid bits.

include/Makefile.am

@@ -18,7 +18,7 @@
 BUILT_SOURCES =		mysql_version.h m_ctype.h my_config.h
 pkginclude_HEADERS =	my_dbug.h m_string.h my_sys.h my_list.h my_xml.h \
 			mysql.h mysql_com.h mysql_embed.h \
-		  	my_semaphore.h my_pthread.h my_no_pthread.h raid.h \
+		  	my_semaphore.h my_pthread.h my_no_pthread.h \
 			errmsg.h my_global.h my_net.h my_alloc.h \
 			my_getopt.h sslopt-longopts.h my_dir.h typelib.h \
 			sslopt-vars.h sslopt-case.h sql_common.h keycache.h \

include/my_sys.h

@@ -915,5 +915,4 @@ void netware_reg_user(const char *ip, const char *user,
 #endif
 
 C_MODE_END
-#include "raid.h"
 #endif /* _my_sys_h */

include/myisam.h

@@ -159,8 +159,6 @@ typedef struct st_mi_isaminfo		/* Struct from h_info */
   uint  reflength;
   ulong record_offset;
   ulong *rec_per_key;			/* for sql optimizing */
-  uint raid_type,raid_chunks;
-  ulong raid_chunksize;
 } MI_ISAMINFO;
 
 
@@ -172,8 +170,6 @@ typedef struct st_mi_create_info
   ulonglong auto_increment;
   ulonglong data_file_length;
   ulonglong key_file_length;
-  uint raid_type,raid_chunks;
-  ulong raid_chunksize;
   uint old_options;
   uint8 language;
   my_bool with_auto_increment;

include/raid.h

-/* Copyright (C) 2000 MySQL AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/* Parser needs these defines  always, even if USE_RAID is not defined */
-#define RAID_TYPE_0 1       /* Striping */
-#define RAID_TYPE_x 2       /* Some new modes */
-#define RAID_TYPE_y 3
-
-#define RAID_DEFAULT_CHUNKS 4
-#define RAID_DEFAULT_CHUNKSIZE 256*1024 /* 256kB */
-
-C_MODE_START
-#define my_raid_type(raid_type)  raid_type_string[(int)(raid_type)]
-extern const char *raid_type_string[];
-C_MODE_END
-
-#ifdef DONT_USE_RAID
-#undef USE_RAID
-#endif
-#if defined(USE_RAID)
-
-#include "my_dir.h"
-
-/* Trap all occurences of my_...() in source and use our wrapper around this function */
-
-#ifdef MAP_TO_USE_RAID
-#define my_read(A,B,C,D)     my_raid_read(A,B,C,D)
-#define my_write(A,B,C,D)    my_raid_write(A,B,C,D)
-#define my_pwrite(A,B,C,D,E) my_raid_pwrite(A,B,C,D,E)
-#define my_pread(A,B,C,D,E)  my_raid_pread(A,B,C,D,E)
-#define my_chsize(A,B,C,D)   my_raid_chsize(A,B,C,D)
-#define my_close(A,B)        my_raid_close(A,B)
-#define my_tell(A,B)         my_raid_tell(A,B)
-#define my_seek(A,B,C,D)     my_raid_seek(A,B,C,D)
-#define my_lock(A,B,C,D,E)     my_raid_lock(A,B,C,D,E)
-#define my_fstat(A,B,C)     my_raid_fstat(A,B,C)
-#endif /* MAP_TO_USE_RAID */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  void init_raid(void);
-  void end_raid(void);
-
-  bool is_raid(File fd);
-  File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
-		      uint raid_type, uint raid_chunks, ulong raid_chunksize,
-		      myf MyFlags);
-  File my_raid_open(const char *FileName, int Flags,
-		    uint raid_type, uint raid_chunks, ulong raid_chunksize,
-		    myf MyFlags);
-  int my_raid_rename(const char *from, const char *to, uint raid_chunks,
-		     myf MyFlags);
-  int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags);
-  int my_raid_redel(const char *old_name, const char *new_name,
-		    uint raid_chunks, myf MyFlags);
-
-  my_off_t my_raid_seek(File fd, my_off_t pos, int whence, myf MyFlags);
-  my_off_t my_raid_tell(File fd, myf MyFlags);
-
-  uint my_raid_write(File,const byte *Buffer, uint Count, myf MyFlags);
-  uint my_raid_read(File Filedes, byte *Buffer, uint Count, myf MyFlags);
-
-  uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
-		     myf MyFlags);
-  uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
-		      my_off_t offset, myf MyFlags);
-
-  int my_raid_lock(File,int locktype, my_off_t start, my_off_t length,
-		   myf MyFlags);
-  int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags);
-  int my_raid_close(File, myf MyFlags);
-  int my_raid_fstat(int Filedes, struct stat *buf,  myf MyFlags);
-
-#ifdef __cplusplus
-}
-
-#ifdef USE_PRAGMA_INTERFACE
-#pragma interface			/* gcc class implementation */
-#endif
-
-class RaidName {
-  public:
-    RaidName(const char *FileName);
-    ~RaidName();
-    bool IsRaid();
-    int Rename(const char * from, const char * to, myf MyFlags);
-  private:
-    uint _raid_type;       /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
-    uint _raid_chunks;     /* 1..n */
-    ulong _raid_chunksize; /* 1..n in bytes */
-};
-
-class RaidFd {
-  public:
-    RaidFd(uint raid_type, uint raid_chunks , ulong raid_chunksize);
-    ~RaidFd();
-    File Create(const char *FileName, int CreateFlags, int access_flags,
-		myf MyFlags);
-    File Open(const char *FileName, int Flags, myf MyFlags);
-    my_off_t Seek(my_off_t pos,int whence,myf MyFlags);
-    my_off_t Tell(myf MyFlags);
-    int Write(const byte *Buffer, uint Count, myf MyFlags);
-    int Read(const byte *Buffer, uint Count, myf MyFlags);
-    int Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags);
-    int Chsize(File fd, my_off_t newlength, int filler, myf MyFlags);
-    int Fstat(int fd, MY_STAT *stat_area, myf MyFlags );
-    int Close(myf MyFlags);
-    static bool IsRaid(File fd);
-    static DYNAMIC_ARRAY _raid_map;		/* Map of RaidFD* */
-  private:
-
-    uint _raid_type;       /* RAID_TYPE_0 or RAID_TYPE_1 or RAID_TYPE_5 */
-    uint _raid_chunks;     /* 1..n */
-    ulong _raid_chunksize; /* 1..n in bytes */
-
-    ulong _total_block;    /* We are operating with block no x (can be 0..many). */
-    uint _this_block;      /* can be 0.._raid_chunks */
-    uint _remaining_bytes; /* Maximum bytes that can be written in this block */
-
-    my_off_t _position;
-    my_off_t _size;        /* Cached file size for faster seek(SEEK_END) */
-    File _fd;
-    File *_fd_vector;		/* Array of File */
-    off_t *_seek_vector;	/* Array of cached seek positions */
-
-    inline void Calculate()
-    {
-      DBUG_ENTER("RaidFd::_Calculate");
-      DBUG_PRINT("info",("_position: %lu _raid_chunksize: %d, _size: %lu",
-			 (ulong) _position, _raid_chunksize, (ulong) _size));
-
-      _total_block = (ulong) (_position / _raid_chunksize);
-      _this_block = _total_block % _raid_chunks;    /* can be 0.._raid_chunks */
-      _remaining_bytes = (uint) (_raid_chunksize -
-				 (_position - _total_block * _raid_chunksize));
-      DBUG_PRINT("info",
-		 ("_total_block: %d  this_block: %d  _remaining_bytes:%d",
-		  _total_block, _this_block, _remaining_bytes));
-      DBUG_VOID_RETURN;
-    }
-};
-
-#endif /* __cplusplus */
-#endif /* USE_RAID */

mysql-test/r/case.result

-drop table if exists t1;
+drop table if exists t1,t2;
 select CASE "b" when "a" then 1 when "b" then 2 END;
 CASE "b" when "a" then 1 when "b" then 2 END
 2

mysql-test/r/mysqlcheck.result

+DROP SCHEMA test;
+CREATE SCHEMA test;
 cluster_replication.binlog_index                   OK
 mysql.columns_priv                                 OK
 mysql.db                                           OK

mysql-test/t/case.test

@@ -3,7 +3,7 @@
 #
 
 --disable_warnings
-drop table if exists t1;
+drop table if exists t1,t2;
 --enable_warnings
 
 select CASE "b" when "a" then 1 when "b" then 2 END;

mysql-test/t/mysqlcheck.test

@@ -5,6 +5,8 @@
 # depends on the presence of the log tables (which are CSV-based).
 --source include/have_csv.inc
 
+DROP SCHEMA test;
+CREATE SCHEMA test;
 #
 # Bug #13783  mysqlcheck tries to optimize and analyze information_schema
 #

mysys/Makefile.am

@@ -51,7 +51,7 @@ libmysys_a_SOURCES =    my_init.c my_getwd.c mf_getdate.c my_mmap.c \
 			my_quick.c my_lockmem.c my_static.c \
 			my_sync.c my_getopt.c my_mkdir.c \
 			default_modify.c default.c \
-                        my_compress.c checksum.c raid.cc \
+                        my_compress.c checksum.c \
 			my_net.c my_semaphore.c my_port.c my_sleep.c \
 			charset.c charset-def.c my_bitmap.c my_bit.c md5.c \
 			my_gethostbyname.c rijndael.c my_aes.c sha1.c \

mysys/my_static.c

@@ -92,13 +92,6 @@ struct st_irem *sf_malloc_root = NULL;
 int volatile my_have_got_alarm=0;	/* declare variable to reset */
 ulong my_time_to_wait_for_lock=2;	/* In seconds */
 
-	/*
-	  We need to have this define here as otherwise linking will fail
-	  on OSF1 when compiling --without-raid --with-debug
-	*/
-
-const char *raid_type_string[]={"none","striped"};
-
 	/* from errors.c */
 #ifdef SHARED_LIBRARY
 char * NEAR globerrs[GLOBERRS];		/* my_error_messages is here */

mysys/raid.cc

-/* Copyright (C) 2000 MySQL AB
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
-   (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
-
-/*
- 
-   RAID support for MySQL. Raid 0 (stiping) only implemented yet.
- 
-   Why RAID? Why it must be in MySQL?
- 
-   This is because then you can:
-   1. Have bigger tables than your OS limit. In time of writing this
-      we are hitting to 2GB limit under linux/ext2
-   2. You can get more speed from IO bottleneck by putting
-      Raid dirs on different physical disks.
-   3. Getting more fault tolerance (not implemented yet)
- 
-   Why not to use RAID:
- 
-   1. You are losing some processor power to calculate things,
-      do more syscalls and interrupts.
- 
-   Functionality is supplied by two classes: RaidFd and RaidName.
-   RaidFd supports funtionality over file descriptors like
-   open/create/write/seek/close. RaidName supports functionality
-   like rename/delete where we have no relations to filedescriptors.
-   RaidName can be prorably unchanged for different Raid levels. RaidFd
-   have to be virtual I think ;).
-   You can speed up some calls in MySQL code by skipping RAID code.
-   For example LOAD DATA INFILE never needs to read RAID-ed files.
-   This can be done adding proper "#undef my_read" or similar undef-s
-   in your code. Check out the raid.h!
- 
-   Some explanation about _seek_vector[]
-   This is seek cache. RAID seeks too much and we cacheing this. We
-   fool it and just storing new position in file to _seek_vector.
-   When there is no seeks to do, we are putting RAID_SEEK_DONE into it.
-   Any other value requires seeking to that position.
- 
-   TODO:
- 
- 
-   -  Implement other fancy things like RAID 1 (mirroring) and RAID 5.
-      Should not to be very complex.
- 
-   -  Optimize big blob writes by resorting write buffers and writing
-      big chunks at once instead of doing many syscalls. - after thinking I
-      found this is useless. This is because same thing one can do with just
-      increasing RAID_CHUNKSIZE. Monty, what do you think? tonu.
- 
-   -  If needed, then implement missing syscalls. One known to miss is stat();
- 
-   -  Make and use a thread safe dynamic_array buffer. The used one
-      will not work if needs to be extended at the same time someone is
-      accessing it.
- 
- 
-   tonu@mysql.com & monty@mysql.com
-*/
-
-#ifdef USE_PRAGMA_IMPLEMENTATION 
-#pragma implementation				// gcc: Class implementation
-#endif
-
-#include "mysys_priv.h"
-#include <my_dir.h>
-#include <m_string.h>
-#include <assert.h>
-
-#if defined(USE_RAID) && !defined(MYSQL_CLIENT)
-
-#define RAID_SEEK_DONE ~(off_t) 0
-#define RAID_SIZE_UNKNOWN ~(my_off_t) 0
-
-DYNAMIC_ARRAY RaidFd::_raid_map;
-
-
-/* ---------------  C compatibility  ---------------*/
-
-extern "C" {
-
-  void init_raid(void)
-  {
-  /* Allocate memory for global file to raid map */
-    my_init_dynamic_array(&RaidFd::_raid_map, sizeof(RaidFd*), 4096, 1024);
-  }
-  void end_raid(void)
-  {
-    /* Free memory used by raid */
-    delete_dynamic(&RaidFd::_raid_map);
-  }
-
-  bool is_raid(File fd)
-  {
-    return RaidFd::IsRaid(fd);
-  }
-
-  File my_raid_create(const char *FileName, int CreateFlags, int access_flags,
-		      uint raid_type, uint raid_chunks, ulong raid_chunksize,
-		      myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_create");
-    DBUG_PRINT("enter",("Filename: %s  CreateFlags: %d  access_flags: %d  MyFlags: %d",
-			FileName, CreateFlags, access_flags, MyFlags));
-    if (raid_type)
-    {
-      RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
-      File res = raid->Create(FileName,CreateFlags,access_flags,MyFlags);
-      if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
-      {
-	delete raid;
-	DBUG_RETURN(-1);
-      }
-      DBUG_RETURN(res);
-    }
-    else
-       DBUG_RETURN(my_create(FileName, CreateFlags, access_flags,  MyFlags));
-  }
-
-  File my_raid_open(const char *FileName, int Flags,
-		    uint raid_type, uint raid_chunks, ulong raid_chunksize,
-		    myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_open");
-    DBUG_PRINT("enter",("Filename: %s  Flags: %d  MyFlags: %d",
-			FileName, Flags, MyFlags));
-    if (raid_type)
-    {
-      RaidFd *raid = new RaidFd(raid_type, raid_chunks , raid_chunksize);
-      File res = raid->Open(FileName,Flags,MyFlags);
-      if (res < 0 || set_dynamic(&RaidFd::_raid_map,(char*) &raid,res))
-      {
-	delete raid;
-	DBUG_RETURN(-1);
-      }
-      DBUG_RETURN(res);
-    }
-    else
-      DBUG_RETURN(my_open(FileName, Flags, MyFlags));
-  }
-
-  my_off_t my_raid_seek(File fd, my_off_t pos,int whence,myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_seek");
-    DBUG_PRINT("enter",("Fd: %d  pos: %lu whence: %d  MyFlags: %d",
-			fd, (ulong) pos, whence, MyFlags));
-
-    if (is_raid(fd))
-    {
-      assert(pos != MY_FILEPOS_ERROR);
-
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      DBUG_RETURN(raid->Seek(pos,whence,MyFlags));
-    }
-    else
-      DBUG_RETURN(my_seek(fd, pos, whence, MyFlags));
-  }
-
-  my_off_t my_raid_tell(File fd,myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_tell");
-    DBUG_PRINT("enter",("Fd: %d  MyFlags: %d",
-			fd, MyFlags));
-    if (is_raid(fd))
-    {
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      DBUG_RETURN(raid->Tell(MyFlags));
-    }
-    else
-       DBUG_RETURN(my_tell(fd, MyFlags));
-  }
-
-  uint my_raid_write(File fd,const byte *Buffer, uint Count, myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_write");
-    DBUG_PRINT("enter",("Fd: %d  Buffer: 0x%lx  Count: %u  MyFlags: %d",
-		      fd, Buffer, Count, MyFlags));
-    if (is_raid(fd))
-    {
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
-    } else
-      DBUG_RETURN(my_write(fd,Buffer,Count,MyFlags));
-  }
-
-  uint my_raid_read(File fd, byte *Buffer, uint Count, myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_read");
-    DBUG_PRINT("enter",("Fd: %d  Buffer: 0x%lx  Count: %u  MyFlags: %d",
-		      fd, Buffer, Count, MyFlags));
-    if (is_raid(fd))
-    {
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
-    } else
-      DBUG_RETURN(my_read(fd,Buffer,Count,MyFlags));
-  }
-
-  uint my_raid_pread(File Filedes, byte *Buffer, uint Count, my_off_t offset,
-		     myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_pread");
-    DBUG_PRINT("enter",
-               ("Fd: %d  Buffer: 0x%lx  Count: %u offset: %u  MyFlags: %d",
-                Filedes, Buffer, Count, offset, MyFlags));
-     if (is_raid(Filedes))
-     {
-       assert(offset != MY_FILEPOS_ERROR);
-
-       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
-       /* Returning value isn't important because real seek is done later. */
-       raid->Seek(offset,MY_SEEK_SET,MyFlags);
-       DBUG_RETURN(raid->Read(Buffer,Count,MyFlags));
-     }
-     else
-       DBUG_RETURN(my_pread(Filedes, Buffer, Count, offset, MyFlags));
-  }
-
-  uint my_raid_pwrite(int Filedes, const byte *Buffer, uint Count,
-		      my_off_t offset, myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_pwrite");
-    DBUG_PRINT("enter",
-               ("Fd: %d  Buffer: 0x %lx  Count: %u offset: %u  MyFlags: %d",
-                Filedes, Buffer, Count, offset, MyFlags));
-     if (is_raid(Filedes))
-     {
-       assert(offset != MY_FILEPOS_ERROR);
-
-       RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,Filedes,RaidFd**));
-       /* Returning value isn't important because real seek is done later. */
-       raid->Seek(offset,MY_SEEK_SET,MyFlags);
-       DBUG_RETURN(raid->Write(Buffer,Count,MyFlags));
-     }
-     else
-       DBUG_RETURN(my_pwrite(Filedes, Buffer, Count, offset, MyFlags));
-  }
-
-  int my_raid_lock(File fd, int locktype, my_off_t start, my_off_t length,
-		   myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_lock");
-    DBUG_PRINT("enter",("Fd: %d  start: %u  length: %u  MyFlags: %d",
-		      fd, start, length, MyFlags));
-    if (my_disable_locking)
-      DBUG_RETURN(0);
-    if (is_raid(fd))
-    {
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      DBUG_RETURN(raid->Lock(locktype, start, length, MyFlags));
-    }
-    else
-      DBUG_RETURN(my_lock(fd, locktype, start, length, MyFlags));
-  }
-
-  int my_raid_close(File fd, myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_close");
-    DBUG_PRINT("enter",("Fd: %d  MyFlags: %d",
-		      fd, MyFlags));
-    if (is_raid(fd))
-    {
-      RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-      RaidFd *tmp=0;
-      set_dynamic(&RaidFd::_raid_map,(char*) &tmp,fd);
-      int res = raid->Close(MyFlags);
-      delete raid;
-      DBUG_RETURN(res);
-    }
-    else
-      DBUG_RETURN(my_close(fd, MyFlags));
-  }
-
-  int my_raid_chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
-  {
-    DBUG_ENTER("my_raid_chsize");
-    DBUG_PRINT("enter",("Fd: %d  newlength: %u  MyFlags: %d",
-		      fd, newlength, MyFlags));
-   if (is_raid(fd))
-   {
-     RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-     DBUG_RETURN(raid->Chsize(fd, newlength, filler, MyFlags));
-   }
-   else
-     DBUG_RETURN(my_chsize(fd, newlength, filler, MyFlags));
-  }
-
-  int my_raid_rename(const char *from, const char *to,
-		     uint raid_chunks, myf MyFlags)
-  {
-    char from_tmp[FN_REFLEN];
-    char to_tmp[FN_REFLEN];
-    DBUG_ENTER("my_raid_rename");
-
-    uint from_pos = dirname_length(from);
-    uint to_pos   = dirname_length(to);
-    memcpy(from_tmp, from, from_pos);
-    memcpy(to_tmp, to, to_pos);
-    for (uint i = 0 ; i < raid_chunks ; i++ )
-    {
-      sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
-      sprintf(to_tmp+to_pos,"%02x/%s", i, to+ to_pos);
-      /* Convert if not unix */
-      unpack_filename(from_tmp, from_tmp);
-      unpack_filename(to_tmp,to_tmp);
-      if (my_rename(from_tmp, to_tmp, MyFlags))
-	DBUG_RETURN(-1);
-    }
-    DBUG_RETURN(0);
-  }
-
-  int my_raid_delete(const char *from, uint raid_chunks, myf MyFlags)
-  {
-    char from_tmp[FN_REFLEN];
-    uint from_pos = dirname_length(from);
-    DBUG_ENTER("my_raid_delete");
-
-    if (!raid_chunks)
-      DBUG_RETURN(my_delete(from,MyFlags));
-    for (uint i = 0 ; i < raid_chunks ; i++ )
-    {
-      memcpy(from_tmp, from, from_pos);
-      sprintf(from_tmp+from_pos,"%02x/%s", i, from + from_pos);
-      /* Convert if not unix */
-      unpack_filename(from_tmp, from_tmp);
-      if (my_delete(from_tmp, MyFlags))
-	DBUG_RETURN(-1);
-    }
-    DBUG_RETURN(0);
-  }
-
-  int my_raid_redel(const char *old_name, const char *new_name,
-		    uint raid_chunks, myf MyFlags)
-  {
-    char new_name_buff[FN_REFLEN], old_name_buff[FN_REFLEN];
-    char *new_end, *old_end;
-    uint i,old_length,new_length;
-    int error=0;
-    DBUG_ENTER("my_raid_redel");
-
-    old_end=old_name_buff+dirname_part(old_name_buff,old_name);
-    old_length=dirname_length(old_name);
-    new_end=new_name_buff+dirname_part(new_name_buff,new_name);
-    new_length=dirname_length(new_name);
-    for (i=0 ;	i < raid_chunks ; i++)
-    {
-      MY_STAT status;
-      sprintf(new_end,"%02x",i);
-      if (my_stat(new_name_buff,&status, MYF(0)))
-      {
-	DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
-      }
-      else
-      {
-	if (my_mkdir(new_name_buff,0777,MYF(0)))
-	{
-	  DBUG_PRINT("error",("mkdir failed for %02x",i));
-	  DBUG_RETURN(-1);
-	}
-      }
-      strxmov(strend(new_end),"/",new_name+new_length,NullS);
-      sprintf(old_end,"%02x/%s",i, old_name+old_length);
-      if (my_redel(old_name_buff, new_name_buff, MyFlags))
-	error=1;
-    }
-    DBUG_RETURN(error);
-  }
-}
-
-int my_raid_fstat(int fd, MY_STAT *stat_area, myf MyFlags )
-{
-  DBUG_ENTER("my_raid_fstat");
-  if (is_raid(fd))
-  {
-    RaidFd *raid= (*dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-    DBUG_RETURN(raid->Fstat(fd, stat_area, MyFlags));
-  }
-  else
-    DBUG_RETURN(my_fstat(fd, stat_area, MyFlags));
-}
-
-
-/* -------------- RaidFd base class begins ----------------*/
-/*
-  RaidFd - raided file is identified by file descriptor
-  this is useful when we open/write/read/close files
-*/
-
-
-bool RaidFd::
-IsRaid(File fd)
-{
-  DBUG_ENTER("RaidFd::IsRaid");
-  DBUG_RETURN((uint) fd < _raid_map.elements &&
-	      *dynamic_element(&RaidFd::_raid_map,fd,RaidFd**));
-}
-
-
-RaidFd::
-RaidFd(uint raid_type, uint raid_chunks, ulong raid_chunksize)
-  :_raid_type(raid_type), _raid_chunks(raid_chunks),
-   _raid_chunksize(raid_chunksize), _position(0), _size(RAID_SIZE_UNKNOWN),
-   _fd_vector(0)
-{
-  DBUG_ENTER("RaidFd::RaidFd");
-  DBUG_PRINT("enter",("RaidFd_type: %u  Disks: %u  Chunksize: %d",
-		   raid_type, raid_chunks, raid_chunksize));
-
-  /* TODO: Here we should add checks if the malloc fails */
-  _seek_vector=0;				/* In case of errors */
-  my_multi_malloc(MYF(MY_WME),
-		  &_seek_vector,sizeof(off_t)*_raid_chunks,
-		  &_fd_vector, sizeof(File) *_raid_chunks,
-		  NullS);
-  if (!RaidFd::_raid_map.buffer)
-  {					/* Not initied */
-    pthread_mutex_lock(&THR_LOCK_open);	/* Ensure that no other thread */
-    if (!RaidFd::_raid_map.buffer)	/* has done init in between */
-      init_raid();
-    pthread_mutex_unlock(&THR_LOCK_open);
-  }
-  DBUG_VOID_RETURN;
-}
-
-
-RaidFd::
-~RaidFd() {
-  DBUG_ENTER("RaidFd::~RaidFd");
-  /* We don't have to free _fd_vector ! */
-  my_free((char*) _seek_vector, MYF(MY_ALLOW_ZERO_PTR));
-  DBUG_VOID_RETURN;
-}
-
-
-File RaidFd::
-Create(const char *FileName, int CreateFlags, int access_flags, myf MyFlags)
-{
-  char RaidFdFileName[FN_REFLEN];
-  DBUG_ENTER("RaidFd::Create");
-  DBUG_PRINT("enter",
-	     ("FileName: %s  CreateFlags: %d  access_flags: %d  MyFlags: %d",
-	      FileName, CreateFlags, access_flags, MyFlags));
-  char DirName[FN_REFLEN];
-  uint pos = dirname_part(DirName, FileName);
-  MY_STAT status;
-  if (!_seek_vector)
-    DBUG_RETURN(-1);				/* Not enough memory */
-
-  uint i = _raid_chunks-1;
-  do
-  {
-    /* Create subdir */
-    (void)sprintf(RaidFdFileName,"%s%02x", DirName,i);
-    unpack_dirname(RaidFdFileName,RaidFdFileName);   /* Convert if not unix */
-    if (my_stat(RaidFdFileName,&status, MYF(0)))
-    {
-      DBUG_PRINT("info",("%02x exists, skipping directory creation",i));
-    }
-    else
-    {
-      if (my_mkdir(RaidFdFileName,0777,MYF(0)))
-      {
-	DBUG_PRINT("error",("mkdir failed for %d",i));
-	goto error;
-      }
-    }
-    /* Create file */
-    sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
-    unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
-    _fd = my_create(RaidFdFileName, CreateFlags ,access_flags, (myf)MyFlags);
-    if (_fd < 0)
-      goto error;
-    _fd_vector[i]=_fd;
-    _seek_vector[i]=RAID_SEEK_DONE;
-  } while (i--);
-  _size=0;
-  DBUG_RETURN(_fd);			/* Last filenr is pointer to map */
-
-error:
-  {
-    int save_errno=my_errno;
-    while (++i < _raid_chunks)
-    {
-      my_close(_fd_vector[i],MYF(0));
-      sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
-      unpack_filename(RaidFdFileName,RaidFdFileName);
-      my_delete(RaidFdFileName,MYF(0));
-    }
-    my_errno=save_errno;
-  }
-  DBUG_RETURN(-1);
-}
-
-
-File RaidFd::
-Open(const char *FileName, int Flags, myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Open");
-  DBUG_PRINT("enter",("FileName: %s  Flags: %d  MyFlags: %d",
-		   FileName, Flags, MyFlags));
-  char DirName[FN_REFLEN];
-  uint pos = dirname_part(DirName, FileName);
-  if (!_seek_vector)
-    DBUG_RETURN(-1);				/* Not enough memory */
-
-  for( uint i = 0 ;  i < _raid_chunks ; i++ )
-  {
-    char RaidFdFileName[FN_REFLEN];
-    sprintf(RaidFdFileName,"%s%02x/%s",DirName, i, FileName + pos);
-    unpack_filename(RaidFdFileName,RaidFdFileName); /* Convert if not unix */
-    _fd = my_open(RaidFdFileName, Flags, MyFlags);
-    if (_fd < 0)
-    {
-      int save_errno=my_errno;
-      while (i-- != 0)
-	my_close(_fd_vector[i],MYF(0));
-      my_errno=save_errno;
-      DBUG_RETURN(_fd);
-    }
-    _fd_vector[i]=_fd;
-    _seek_vector[i]=RAID_SEEK_DONE;
-  }
-  Seek(0L,MY_SEEK_END,MYF(0)); // Trick. We just need to know, how big the file is
-  DBUG_PRINT("info",("MYD file logical size: %llu", _size));
-  DBUG_RETURN(_fd);
-}
-
-
-int RaidFd::
-Write(const byte *Buffer, uint Count, myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Write");
-  DBUG_PRINT("enter",("Count: %d  MyFlags: %d",
-		      Count, MyFlags));
-  const byte *bufptr = Buffer;
-  uint res=0, GotBytes, ReadNowCount;
-
-  // Loop until data is written
-  do {
-    Calculate();
-     // Do seeks when neccessary
-    if (_seek_vector[_this_block] != RAID_SEEK_DONE)
-    {
-      if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
-		  MY_SEEK_SET,
-		  MyFlags) == MY_FILEPOS_ERROR)
-	DBUG_RETURN(-1);
-      _seek_vector[_this_block]=RAID_SEEK_DONE;
-    }
-    ReadNowCount = min(Count, _remaining_bytes);
-    GotBytes = my_write(_fd_vector[_this_block], bufptr, ReadNowCount,
-			MyFlags);
-    DBUG_PRINT("loop",("Wrote bytes: %d", GotBytes));
-    if (GotBytes == MY_FILE_ERROR)
-      DBUG_RETURN(-1);
-    res+= GotBytes;
-    if (MyFlags & (MY_NABP | MY_FNABP))
-      GotBytes=ReadNowCount;
-    bufptr += GotBytes;
-    Count  -= GotBytes;
-    _position += GotBytes;
-  } while(Count);
-  set_if_bigger(_size,_position);
-  DBUG_RETURN(res);
-}
-
-
-int RaidFd::
-Read(const byte *Buffer, uint Count, myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Read");
-  DBUG_PRINT("enter",("Count: %d  MyFlags: %d",
-		      Count, MyFlags));
-  byte *bufptr = (byte *)Buffer;
-  uint res= 0, GotBytes, ReadNowCount;
-
-  // Loop until all data is read (Note that Count may be 0)
-  while (Count)
-  {
-    Calculate();
-    // Do seek when neccessary
-    if (_seek_vector[_this_block] != RAID_SEEK_DONE)
-    {
-      if (my_seek(_fd_vector[_this_block], _seek_vector[_this_block],
-		  MY_SEEK_SET,
-		  MyFlags) == MY_FILEPOS_ERROR)
-	DBUG_RETURN(-1);
-      _seek_vector[_this_block]=RAID_SEEK_DONE;
-    }
-    // and read
-    ReadNowCount = min(Count, _remaining_bytes);
-    GotBytes = my_read(_fd_vector[_this_block], bufptr, ReadNowCount,
-		       MyFlags & ~(MY_NABP | MY_FNABP));
-    DBUG_PRINT("loop",("Got bytes: %u", GotBytes));
-    if (GotBytes == MY_FILE_ERROR)
-      DBUG_RETURN(-1);
-    if (!GotBytes)				// End of file.
-    {
-      DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? -1 : (int) res);
-    }
-    res+= GotBytes;
-    bufptr += GotBytes;
-    Count  -= GotBytes;
-    _position += GotBytes;
-  }
-  DBUG_RETURN((MyFlags & (MY_NABP | MY_FNABP)) ? 0 : res);
-}
-
-
-int RaidFd::
-Lock(int locktype, my_off_t start, my_off_t length, myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Lock");
-  DBUG_PRINT("enter",("locktype: %d  start: %lu  length: %lu  MyFlags: %d",
-		      locktype, start, length, MyFlags));
-  my_off_t bufptr = start;
-  // Loop until all data is locked
-  while(length)
-  {
-    Calculate();
-    for (uint i = _this_block ; (i < _raid_chunks) && length ; i++ )
-    {
-       uint ReadNowCount = min(length, _remaining_bytes);
-       uint GotBytes = my_lock(_fd_vector[i], locktype, bufptr, ReadNowCount,
-			MyFlags);
-       if ((int) GotBytes == -1)
-	 DBUG_RETURN(-1);
-       bufptr += ReadNowCount;
-       length  -= ReadNowCount;
-       Calculate();
-    }
-  }
-  DBUG_RETURN(0);
-}
-
-
-int RaidFd::
-Close(myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Close");
-  DBUG_PRINT("enter",("MyFlags: %d",
-		   MyFlags));
-  for (uint i = 0 ; i < _raid_chunks ; ++i )
-  {
-    int err = my_close(_fd_vector[i], MyFlags);
-    if (err != 0)
-      DBUG_RETURN(err);
-  }
-  /* _fd_vector is erased when RaidFd is released */
-  DBUG_RETURN(0);
-}
-
-
-my_off_t RaidFd::
-Seek(my_off_t pos,int whence,myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Seek");
-  DBUG_PRINT("enter",("Pos: %lu  Whence: %d  MyFlags: %d",
-		   (ulong) pos, whence, MyFlags));
-  switch (whence) {
-  case MY_SEEK_CUR:
-    // FIXME: This is wrong, what is going on there
-    // Just I am relied on fact that MySQL 3.23.7 never uses MY_SEEK_CUR
-    // for anything else except things like ltell()
-    break;
-  case MY_SEEK_SET:
-    if ( _position != pos) // we can be already in right place
-    {
-      uint i;
-      off_t _rounds;
-      _position = pos;
-      Calculate();
-      _rounds = _total_block / _raid_chunks;	    // INT() assumed
-      _rounds*= _raid_chunksize;
-      for (i = 0; i < _raid_chunks ; i++ )
-	if ( i < _this_block )
-	  _seek_vector[i] = _rounds + _raid_chunksize;
-	else if ( i == _this_block )
-	  _seek_vector[i] = _rounds + _raid_chunksize -_remaining_bytes;
-	else					// if ( i > _this_block )
-	  _seek_vector[i] = _rounds;
-    }
-    break;
-  case MY_SEEK_END:
-    if (_size==RAID_SIZE_UNKNOWN) // We don't know table size yet
-    {
-      uint i;
-      _position = 0;
-      for (i = 0; i < _raid_chunks ; i++ )
-      {
-	my_off_t newpos = my_seek(_fd_vector[i], 0L, MY_SEEK_END, MyFlags);
-	if (newpos == MY_FILEPOS_ERROR)
-	  DBUG_RETURN (MY_FILEPOS_ERROR);
-	_seek_vector[i]=RAID_SEEK_DONE;
-	_position += newpos;
-      }
-      _size=_position;
-    }
-    else if (_position != _size) // Aren't we also already in the end?
-    {
-      uint i;
-      off_t _rounds;
-      _position = _size;
-      Calculate();
-      _rounds = _total_block / _raid_chunks;	    // INT() assumed
-      _rounds*= _raid_chunksize;
-      for (i = 0; i < _raid_chunks ; i++ )
-	if ( i < _this_block )
-	  _seek_vector[i] = _rounds + _raid_chunksize;
-	else if ( i == _this_block )
-	  _seek_vector[i] = _rounds + _raid_chunksize - _remaining_bytes;
-	else					// if ( i > _this_block )
-	  _seek_vector[i] = _rounds;
-      _position=_size;
-    }
-  }
-  DBUG_RETURN(_position);
-}
-
-
-my_off_t RaidFd::
-Tell(myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Tell");
-  DBUG_PRINT("enter",("MyFlags: %d _position %d",
-		   MyFlags,_position));
-  DBUG_RETURN(_position);
-}
-
-int RaidFd::
-Chsize(File fd, my_off_t newlength, int filler, myf MyFlags)
-{
-  DBUG_ENTER("RaidFd::Chsize");
-  DBUG_PRINT("enter",("Fd: %d, newlength: %d, MyFlags: %d",
-		   fd, newlength,MyFlags));
-  _position = newlength;
-  Calculate();
-  uint _rounds = _total_block / _raid_chunks;	     // INT() assumed
-  for (uint i = 0; i < _raid_chunks ; i++ )
-  {
-    int newpos;
-    if ( i < _this_block )
-      newpos = my_chsize(_fd_vector[i],
-			 _this_block * _raid_chunksize + (_rounds + 1) *
-			 _raid_chunksize, filler, MyFlags);
-    else if ( i == _this_block )
-      newpos = my_chsize(_fd_vector[i],
-			 _this_block * _raid_chunksize + _rounds *
-			 _raid_chunksize + (newlength % _raid_chunksize),
-			 filler, MyFlags);
-    else // this means: i > _this_block
-      newpos = my_chsize(_fd_vector[i],
-			 _this_block * _raid_chunksize + _rounds *
-			 _raid_chunksize, filler, MyFlags);
-    if (newpos)
-      DBUG_RETURN(1);
-  }
-  DBUG_RETURN(0);
-}
-
-
-int RaidFd::
-Fstat(int fd, MY_STAT *stat_area, myf MyFlags )
-{
-  DBUG_ENTER("RaidFd::Fstat");
-  DBUG_PRINT("enter",("fd: %d MyFlags: %d",fd,MyFlags));
-  uint i;
-  int error=0;
-  MY_STAT status;
-  stat_area->st_size=0;
-  stat_area->st_mtime=0;
-  stat_area->st_atime=0;
-  stat_area->st_ctime=0;
-
-  for(i=0 ; i < _raid_chunks ; i++)
-  {
-    if (my_fstat(_fd_vector[i],&status,MyFlags))
-      error=1;
-    stat_area->st_size+=status.st_size;
-    set_if_bigger(stat_area->st_mtime,status.st_mtime);
-    set_if_bigger(stat_area->st_atime,status.st_atime);
-    set_if_bigger(stat_area->st_ctime,status.st_ctime);
-  }
-  DBUG_RETURN(error);
-}
-
-#endif /* defined(USE_RAID) && !defined(MYSQL_CLIENT) */

mysys/raid2.c

-/* Copyright (C) 2002 MySQL AB
-   
-   This library is free software; you can redistribute it and/or
-   modify it under the terms of the GNU Library General Public
-   License as published by the Free Software Foundation; either
-   version 2 of the License, or (at your option) any later version.
-   
-   This library is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-   Library General Public License for more details.
-   
-   You should have received a copy of the GNU Library General Public
-   License along with this library; if not, write to the Free
-   Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
-   MA 02111-1307, USA */
-
-/*
-  RAID support for MySQL. For full comments, check raid.cc
-  This is in a separate file to not cause problems on OS that can't
-  put C++ files in archives.
-*/
-
-#include "mysys_priv.h"
-
-const char *raid_type_string[]={"none","striped"};
-
-const char *my_raid_type(int raid_type)
-{
-  return raid_type_string[raid_type];
-}

storage/myisam/mi_check.c

@@ -3900,9 +3900,6 @@ int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename)
 
   create_info.data_file_length=file_length;
   create_info.auto_increment=share.state.auto_increment;
-  create_info.raid_type=   share.base.raid_type;
-  create_info.raid_chunks= share.base.raid_chunks;
-  create_info.raid_chunksize= share.base.raid_chunksize;
   create_info.language = (param->language ? param->language :
 			  share.state.header.language);
   create_info.key_file_length=  status_info.key_file_length;

storage/myisam/mi_info.c

@@ -85,13 +85,6 @@ int mi_status(MI_INFO *info, register MI_ISAMINFO *x, uint flag)
     x->key_map	 	= share->state.key_map;
     x->data_file_name   = share->data_file_name;
     x->index_file_name  = share->index_file_name;
-    /*
-      The following should be included even if we are not compiling with
-      USE_RAID as the client must be able to request it!
-    */
-    x->raid_type= share->base.raid_type;
-    x->raid_chunks= share->base.raid_chunks;
-    x->raid_chunksize= share->base.raid_chunksize;
   }
   if ((flag & HA_STATUS_TIME) && !my_fstat(info->dfile,&state,MYF(0)))
     x->update_time=state.st_mtime;