Commit f503efea authored by serg@serg.mysql.com's avatar serg@serg.mysql.com
Browse files

Merge work:/home/bk/mysql-4.0 

into serg.mysql.com:/usr/home/serg/Abk/mysql-4.0
parents 8bcd1be2 55f66604

include/my_sys.h

+68 −13
Original line number Diff line number Diff line
@@ -307,6 +307,45 @@ typedef struct st_dynamic_string 
struct st_io_cache;

typedef int (*IO_CACHE_CALLBACK)(struct st_io_cache*);



#ifdef THREAD

typedef struct st_io_cache_share

{

  /* to sync on reads into buffer */

  pthread_mutex_t mutex;

  pthread_cond_t  cond;

  int             count;

  /* actual IO_CACHE that filled the buffer */

  struct st_io_cache *active;

  /* the following will be implemented whenever the need arises */

#ifdef NOT_IMPLEMENTED

  /* whether the structure should be free'd */

  my_bool alloced;

#endif

} IO_CACHE_SHARE;



#define lock_io_cache(info)                                              \

  (                                                                      \

    (errno=pthread_mutex_lock(&((info)->share->mutex))) ? -1 : (         \

      (info)->share->count ? (                                           \

        --((info)->share->count),                                        \

        pthread_cond_wait(&((info)->share->cond),                        \

                          &((info)->share->mutex)),                      \

        (++((info)->share->count) ?                                      \

          pthread_mutex_unlock(&((info)->share->mutex)) : 0))            \

        : 1 )                                                            \

  )



#define unlock_io_cache(info)                                            \

  (                                                                      \

    pthread_cond_broadcast(&((info)->share->cond)),                      \

    pthread_mutex_unlock  (&((info)->share->mutex))                      \

  )

/* -- to catch errors

#else

#define lock_io_cache(info)

#define unlock_io_cache(info)

*/

#endif



typedef struct st_io_cache		/* Used when cacheing files */

{
@@ -347,10 +386,20 @@ typedef struct st_io_cache /* Used when cacheing files */ 
    WRITE_CACHE, and &read_pos and &read_end respectively otherwise

  */

  byte  **current_pos, **current_end;

/* The lock is for append buffer used in SEQ_READ_APPEND cache */

#ifdef THREAD

  /*

    The lock is for append buffer used in SEQ_READ_APPEND cache

    need mutex copying from append buffer to read buffer.

  */

  pthread_mutex_t append_buffer_lock;

  /* need mutex copying from append buffer to read buffer */

  /*

    The following is used when several threads are reading the

    same file in parallel. They are synchronized on disk

    accesses reading the cached part of the file asynchronously.

    It should be set to NULL to disable the feature.  Only

    READ_CACHE mode is supported.

  */

  IO_CACHE_SHARE *share;

#endif

  /*

    A caller will use my_b_read() macro to read from the cache
@@ -635,6 +684,12 @@ extern my_bool reinit_io_cache(IO_CACHE *info,enum cache_type type, 
			       my_off_t seek_offset,pbool use_async_io,

			       pbool clear_cache);

extern int _my_b_read(IO_CACHE *info,byte *Buffer,uint Count);

#ifdef THREAD

extern int _my_b_read_r(IO_CACHE *info,byte *Buffer,uint Count);

extern int init_io_cache_share(IO_CACHE *info,

                             IO_CACHE_SHARE *s, uint num_threads);

extern int remove_io_thread(IO_CACHE *info);

#endif

extern int _my_b_seq_read(IO_CACHE *info,byte *Buffer,uint Count);

extern int _my_b_net_read(IO_CACHE *info,byte *Buffer,uint Count);

extern int _my_b_get(IO_CACHE *info);

include/myisam.h

+41 −32
Original line number Diff line number Diff line
@@ -319,25 +319,6 @@ typedef struct st_sort_key_blocks /* Used when sorting */ 
  int inited;

} SORT_KEY_BLOCKS;



struct st_mi_check_param;



typedef struct st_sort_info

{

  MI_INFO *info;

  struct st_mi_check_param *param;

  enum data_file_type new_data_file_type;

  SORT_KEY_BLOCKS *key_block,*key_block_end;

  uint key,find_length,real_key_length;

  my_off_t pos,max_pos,filepos,start_recpos,filelength,dupp,buff_length;

  ha_rows max_records;

  ulonglong unique[MI_MAX_KEY_SEG+1];

  my_bool fix_datafile;

  char *record,*buff;

  void *wordlist, *wordptr;

  MI_KEYDEF *keyinfo;

  MI_KEYSEG *keyseg;

} SORT_INFO;



typedef struct st_mi_check_param

{

  ulonglong auto_increment_value;
@@ -360,7 +341,6 @@ typedef struct st_mi_check_param 
  int tmpfile_createflag;

  myf myf_rw;

  IO_CACHE read_cache;

  SORT_INFO sort_info;

  ulonglong unique_count[MI_MAX_KEY_SEG+1];

  ha_checksum key_crc[MI_MAX_POSSIBLE_KEY];

  ulong rec_per_key_part[MI_MAX_KEY_SEG*MI_MAX_POSSIBLE_KEY];
@@ -369,18 +349,44 @@ typedef struct st_mi_check_param 
  char *op_name;

} MI_CHECK;





typedef struct st_mi_sortinfo

typedef struct st_sort_info

{

  MI_INFO *info;

  MI_CHECK *param;

  enum data_file_type new_data_file_type;

  SORT_KEY_BLOCKS *key_block,*key_block_end;

  uint kei, total_keys;

  my_off_t filelength,dupp,buff_length;

  ha_rows max_records;

  char *buff;

  myf myf_rw;

  /* sync things*/

  uint got_error, threads_running;

  pthread_mutex_t mutex;

  pthread_cond_t  cond;

} SORT_INFO;



typedef struct st_mi_sort_param

{

  pthread_t  thr;

  IO_CACHE read_cache;

  ulonglong unique[MI_MAX_KEY_SEG+1];

  uint key, key_length,real_key_length,sortbuff_size;

  uint maxbuffers, keys, find_length, sort_keys_length;

  uchar **sort_keys;

  void *wordlist, *wordptr;

  MI_KEYDEF *keyinfo;

  SORT_INFO *sort_info;

  IO_CACHE tempfile, tempfile_for_exceptions;

  DYNAMIC_ARRAY buffpek;

  my_off_t pos,max_pos,filepos,start_recpos;

  my_bool fix_datafile;

  char *record;

  char *tmpdir;

  int (*key_cmp)(SORT_INFO *info, const void *, const void *);

  int (*key_read)(SORT_INFO *info,void *buff);

  int (*key_write)(SORT_INFO *info, const void *buff);

  void (*lock_in_memory)(MI_CHECK *info);

  uint key_length;

  myf myf_rw;

  int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *);

  int (*key_read)(struct st_mi_sort_param *,void *);

  int (*key_write)(struct st_mi_sort_param *, const void *);

  void (*lock_in_memory)(MI_CHECK *);

} MI_SORT_PARAM;



/* functions in mi_check */
@@ -405,14 +411,17 @@ int flush_blocks(MI_CHECK *param, File file); 
void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,

			       my_bool repair);

int update_state_info(MI_CHECK *param, MI_INFO *info,uint update);

void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,

			     ulonglong *unique, ulonglong records);

int filecopy(MI_CHECK *param, File to,File from,my_off_t start,

	     my_off_t length, const char *type);

int movepoint(MI_INFO *info,byte *record,my_off_t oldpos,

	      my_off_t newpos, uint prot_key);

int sort_write_record(SORT_INFO *sort_info);

int write_data_suffix(MI_CHECK *param, MI_INFO *info);

int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages,

			  ulong);

int sort_write_record(MI_SORT_PARAM *sort_param);

int write_data_suffix(SORT_INFO *sort_info, my_bool fix_datafile);

int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages, ulong);

void *_thr_find_all_keys(MI_SORT_PARAM *info);

int _thr_write_keys(MI_SORT_PARAM *sort_param);

int test_if_almost_full(MI_INFO *info);

int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename);

void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows);

myisam/mi_cache.c

+34 −30
Original line number Diff line number Diff line
@@ -14,14 +14,26 @@ 
   along with this program; if not, write to the Free Software

   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */



/* Functions for read record cacheing with myisam */

/* Used instead of my_b_read() to allow for no-cacheed seeks */

/*

  Functions for read record cacheing with myisam

  Used for reading dynamic/compressed records from datafile.



#include "myisamdef.h"

  Can fetch data directly from file (outside cache),

  if reading a small chunk straight before the cached part (with possible

  overlap).



  Can be explicitly asked not to use cache (by not setting READING_NEXT in

  flag) - useful for occasional out-of-cache reads, when the next read is

  expected to hit the cache again.



  Allows "partial read" errors in the record header (when READING_HEADER flag

  is set) - unread part is bzero'ed



	/* Copy block from cache if it`s in it. If re_read_if_possibly is */

	/* set read to cache (if after current file-position) else read to */

	/* buff								  */

  Note: out-of-cache reads are disabled for shared IO_CACHE's

*/





#include "myisamdef.h"



int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length,

		   int flag)
@@ -31,7 +43,7 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length, 
  char *in_buff_pos;

  DBUG_ENTER("_mi_read_cache");



  if (pos < info->pos_in_file)

  if (pos < info->pos_in_file && ! info->share)

  {

    read_length=length;

    if ((my_off_t) read_length > (my_off_t) (info->pos_in_file-pos))
@@ -44,7 +56,8 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length, 
    pos+=read_length;

    buff+=read_length;

  }

  if ((offset= (my_off_t) (pos - info->pos_in_file)) <

  if (pos >= info->pos_in_file &&

      (offset= (my_off_t) (pos - info->pos_in_file)) <

      (my_off_t) (info->read_end - info->request_pos))

  {

    in_buff_pos=info->request_pos+(uint) offset;
@@ -57,10 +70,10 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length, 
  }

  else

    in_buff_length=0;

  if (flag & READING_NEXT)

  if (flag & READING_NEXT || info->share)

  {

    if (pos != ((info)->pos_in_file +

		(uint) ((info)->read_end - (info)->request_pos)))

    if (pos !=

        (info->pos_in_file + (uint) (info->read_end - info->request_pos)))

    {

      info->pos_in_file=pos;				/* Force start here */

      info->read_pos=info->read_end=info->request_pos;	/* Everything used */
@@ -70,28 +83,19 @@ int _mi_read_cache(IO_CACHE *info, byte *buff, my_off_t pos, uint length, 
      info->read_pos=info->read_end;			/* All block used */

    if (!(*info->read_function)(info,buff,length))

      DBUG_RETURN(0);

    if (!(flag & READING_HEADER) || info->error == -1 ||

	(uint) info->error+in_buff_length < 3)

    {

      DBUG_PRINT("error",

		 ("Error %d reading next-multi-part block (Got %d bytes)",

		  my_errno, info->error));

      if (!my_errno || my_errno == -1)

	my_errno=HA_ERR_WRONG_IN_RECORD;

      DBUG_RETURN(1);

    }

    bzero(buff+info->error,MI_BLOCK_INFO_HEADER_LENGTH - in_buff_length -

	  (uint) info->error);

    DBUG_RETURN(0);

    read_length=info->error;

  }

  else

  {

    info->seek_not_done=1;

    if ((read_length=my_pread(info->file,buff,length,pos,MYF(0))) == length)

      DBUG_RETURN(0);

  }

  if (!(flag & READING_HEADER) || (int) read_length == -1 ||

      read_length+in_buff_length < 3)

  {

    DBUG_PRINT("error",

	       ("Error %d reading new block (Got %d bytes)",

               ("Error %d reading next-multi-part block (Got %d bytes)",

                my_errno, (int) read_length));

    if (!my_errno || my_errno == -1)

      my_errno=HA_ERR_WRONG_IN_RECORD;

myisam/mi_check.c

+630 −284

File changed.

Preview size limit exceeded, changes collapsed.

myisam/mi_write.c

+2 −1
Original line number Diff line number Diff line
@@ -823,7 +823,8 @@ int _mi_init_bulk_insert(MI_INFO *info) 
    }

  }



  if (num_keys==0 || num_keys > myisam_bulk_insert_tree_size)

  if (num_keys==0 ||

      num_keys * MI_MIN_SIZE_BULK_INSERT_TREE > myisam_bulk_insert_tree_size)

    DBUG_RETURN(0);



  info->bulk_insert=(TREE *)