← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

  • Committer: Monty Taylor
  • Date: 2009-01-30 21:02:37 UTC
  • mto: (779.7.3 devel)
  • mto: This revision was merged to the branch mainline in revision 823.
  • Revision ID: mordred@inaugust.com-20090130210237-3n6ld8a9jc084jko
Commented out a test in subselect_sj - I think it might be a regression. Jay?

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_open.c
17
17
 
18
18
#include "myisamdef.h"
19
19
#include <mystrings/m_ctype.h>
 
20
#include <mystrings/m_string.h>
 
21
#include <drizzled/util/test.h>
 
22
 
 
23
#include <string.h>
20
24
 
21
25
static void setup_key_functions(MI_KEYDEF *keyinfo);
22
 
#define get_next_element(to,pos,size) \
23
 
  do {                                \
24
 
    memcpy(to, pos, size);            \
25
 
    pos+=size;                        \
26
 
  } while (0)
27
 
 
28
26
 
29
27
#define disk_pos_assert(pos, end_pos) \
30
28
if (pos > end_pos)             \
62
60
  have an open count of 0.
63
61
******************************************************************************/
64
62
 
65
 
MI_INFO *mi_open(const char *name, int mode, uint open_flags)
 
63
MI_INFO *mi_open(const char *name, int mode, uint32_t open_flags)
66
64
{
67
65
  int lock_error,kfile,open_mode,save_errno,have_rtree=0;
68
 
  uint i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
 
66
  uint32_t i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
69
67
    key_parts,unique_key_parts,fulltext_keys,uniques;
70
68
  char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
71
69
       data_name[FN_REFLEN];
72
 
  uchar *disk_cache, *disk_pos, *end_pos;
 
70
  unsigned char *disk_cache= NULL;
 
71
  unsigned char *disk_pos, *end_pos;
73
72
  MI_INFO info,*m_info,*old_info;
74
73
  MYISAM_SHARE share_buff,*share;
75
74
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
92
91
    share_buff.state.rec_per_key_part=rec_per_key_part;
93
92
    share_buff.state.key_root=key_root;
94
93
    share_buff.state.key_del=key_del;
95
 
    share_buff.key_cache= multi_key_cache_search((uchar*) name_buff,
 
94
    share_buff.key_cache= multi_key_cache_search((unsigned char*) name_buff,
96
95
                                                 strlen(name_buff));
97
96
 
98
 
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
 
97
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
99
98
    {
100
99
      if ((errno != EROFS && errno != EACCES) ||
101
100
          mode != O_RDONLY ||
102
 
          (kfile=my_open(name_buff,(open_mode=O_RDONLY) | O_SHARE,MYF(0))) < 0)
 
101
          (kfile=my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
103
102
        goto err;
104
103
    }
105
104
    share->mode=open_mode;
135
134
    /* Don't call realpath() if the name can't be a link */
136
135
    if (!strcmp(name_buff, org_name) ||
137
136
        my_readlink(index_name, org_name, MYF(0)) == -1)
138
 
      (void) stpcpy(index_name, org_name);
 
137
      (void) strcpy(index_name, org_name);
139
138
    *strrchr(org_name, '.')= '\0';
140
139
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
141
140
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
142
141
 
143
142
    info_length=mi_uint2korr(share->state.header.header_length);
144
143
    base_pos=mi_uint2korr(share->state.header.base_pos);
145
 
    if (!(disk_cache= (uchar*) my_alloca(info_length+128)))
 
144
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
146
145
    {
147
146
      my_errno=ENOMEM;
148
147
      goto err;
150
149
    end_pos=disk_cache+info_length;
151
150
    errpos=2;
152
151
 
153
 
    VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
 
152
    lseek(kfile,0,SEEK_SET);
154
153
    errpos=3;
155
154
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
156
155
    {
204
203
      mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
205
204
                  ((uint64_t) 1 << (share->base.key_reflength*8))-1);
206
205
#if SIZEOF_OFF_T == 4
207
 
    set_if_smaller(max_data_file_length, INT_MAX32);
208
 
    set_if_smaller(max_key_file_length, INT_MAX32);
 
206
    set_if_smaller(max_data_file_length, INT32_MAX);
 
207
    set_if_smaller(max_key_file_length, INT32_MAX);
209
208
#endif
210
209
    if (share->base.raid_type)
211
210
    {
238
237
                         &share->state.key_root,keys*sizeof(my_off_t),
239
238
                         &share->state.key_del,
240
239
                         (share->state.header.max_block_size_index*sizeof(my_off_t)),
241
 
                         &share->key_root_lock,sizeof(rw_lock_t)*keys,
242
 
                         &share->mmap_lock,sizeof(rw_lock_t),
243
 
                         NullS))
 
240
                         &share->key_root_lock,sizeof(pthread_rwlock_t)*keys,
 
241
                         &share->mmap_lock,sizeof(pthread_rwlock_t),
 
242
                         NULL))
244
243
      goto err;
245
244
    errpos=4;
246
245
    *share=share_buff;
250
249
           sizeof(my_off_t)*keys);
251
250
    memcpy(share->state.key_del, key_del,
252
251
           sizeof(my_off_t) * share->state.header.max_block_size_index);
253
 
    stpcpy(share->unique_file_name, name_buff);
 
252
    strcpy(share->unique_file_name, name_buff);
254
253
    share->unique_name_length= strlen(name_buff);
255
 
    stpcpy(share->index_file_name,  index_name);
256
 
    stpcpy(share->data_file_name,   data_name);
 
254
    strcpy(share->index_file_name,  index_name);
 
255
    strcpy(share->data_file_name,   data_name);
257
256
 
258
 
    share->blocksize=min(IO_SIZE,myisam_block_size);
 
257
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
259
258
    {
260
259
      HA_KEYSEG *pos=share->keyparts;
261
260
      for (i=0 ; i < keys ; i++)
374
373
    share->base.margin_key_file_length=(share->base.max_key_file_length -
375
374
                                        (keys ? MI_INDEX_BLOCK_MARGIN *
376
375
                                         share->blocksize * keys : 0));
377
 
    share->blocksize=min(IO_SIZE,myisam_block_size);
 
376
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
378
377
    share->data_file_type=STATIC_RECORD;
379
378
    if (share->options & HA_OPTION_PACK_RECORD)
380
379
      share->data_file_type = DYNAMIC_RECORD;
381
 
    my_afree(disk_cache);
 
380
    free(disk_cache);
 
381
    disk_cache= NULL;
382
382
    mi_setup_functions(share);
383
383
    share->is_log_table= false;
384
384
    thr_lock_init(&share->lock);
385
 
    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
 
385
    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
386
386
    for (i=0; i<keys; i++)
387
 
      VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
388
 
    VOID(my_rwlock_init(&share->mmap_lock, NULL));
 
387
      pthread_rwlock_init(&share->key_root_lock[i], NULL);
 
388
    pthread_rwlock_init(&share->mmap_lock, NULL);
389
389
    if (!thr_lock_inited)
390
390
    {
391
391
      /* Probably a single threaded program; Don't use concurrent inserts */
440
440
                       &info.first_mbr_key, share->base.max_key_length,
441
441
                       &info.filename,strlen(name)+1,
442
442
                       &info.rtree_recursion_state,have_rtree ? 1024 : 0,
443
 
                       NullS))
 
443
                       NULL))
444
444
    goto err;
445
445
  errpos=6;
446
446
 
447
447
  if (!have_rtree)
448
448
    info.rtree_recursion_state= NULL;
449
449
 
450
 
  stpcpy(info.filename,name);
 
450
  strcpy(info.filename,name);
451
451
  memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
452
452
  info.lastkey2=info.lastkey+share->base.max_key_length;
453
453
 
510
510
  return(m_info);
511
511
 
512
512
err:
 
513
  if (disk_cache != NULL)
 
514
    free(disk_cache);
513
515
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
514
516
  if ((save_errno == HA_ERR_CRASHED) ||
515
517
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
517
519
    mi_report_error(save_errno, name);
518
520
  switch (errpos) {
519
521
  case 6:
520
 
    my_free((uchar*) m_info,MYF(0));
 
522
    free((unsigned char*) m_info);
521
523
    /* fall through */
522
524
  case 5:
523
 
    VOID(my_close(info.dfile,MYF(0)));
 
525
    my_close(info.dfile,MYF(0));
524
526
    if (old_info)
525
527
      break;                                    /* Don't remove open table */
526
528
    /* fall through */
527
529
  case 4:
528
 
    my_free((uchar*) share,MYF(0));
 
530
    free((unsigned char*) share);
529
531
    /* fall through */
530
532
  case 3:
531
533
    /* fall through */
532
 
  case 2:
533
 
    my_afree(disk_cache);
534
 
    /* fall through */
535
534
  case 1:
536
 
    VOID(my_close(kfile,MYF(0)));
 
535
    my_close(kfile,MYF(0));
537
536
    /* fall through */
538
537
  case 0:
539
538
  default:
545
544
} /* mi_open */
546
545
 
547
546
 
548
 
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
 
547
unsigned char *mi_alloc_rec_buff(MI_INFO *info, size_t length, unsigned char **buf)
549
548
{
550
 
  uint extra;
 
549
  uint32_t extra;
551
550
  uint32_t old_length= 0;
552
551
 
553
552
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
554
553
  {
555
 
    uchar *newptr = *buf;
 
554
    unsigned char *newptr = *buf;
556
555
 
557
556
    /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
558
557
    if (length == (ulong) -1)
559
558
    {
560
559
      if (info->s->options & HA_OPTION_COMPRESS_RECORD)
561
 
        length= max(info->s->base.pack_reclength, info->s->max_pack_length);
 
560
        length= cmax(info->s->base.pack_reclength, info->s->max_pack_length);
562
561
      else
563
562
        length= info->s->base.pack_reclength;
564
 
      length= max(length, info->s->base.max_key_length);
 
563
      length= cmax(length, info->s->base.max_key_length);
565
564
      /* Avoid unnecessary realloc */
566
565
      if (newptr && length == old_length)
567
566
        return newptr;
572
571
            MI_REC_BUFF_OFFSET : 0);
573
572
    if (extra && newptr)
574
573
      newptr-= MI_REC_BUFF_OFFSET;
575
 
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
576
 
                                     MYF(MY_ALLOW_ZERO_PTR))))
 
574
    void *tmpnewptr= NULL;
 
575
    if (!(tmpnewptr= realloc(newptr, length+extra+8))) 
577
576
      return newptr;
 
577
    newptr= tmpnewptr;
578
578
    *((uint32_t *) newptr)= (uint32_t) length;
579
579
    *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
580
580
  }
693
693
   Function to save and store the header in the index file (.MYI)
694
694
*/
695
695
 
696
 
uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
 
696
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
697
697
{
698
 
  uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
699
 
  uchar *ptr=buff;
 
698
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
699
  unsigned char *ptr=buff;
700
700
  uint  i, keys= (uint) state->header.keys,
701
701
        key_blocks=state->header.max_block_size_index;
702
702
 
705
705
 
706
706
  /* open_count must be first because of _mi_mark_file_changed ! */
707
707
  mi_int2store(ptr,state->open_count);          ptr +=2;
708
 
  *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
 
708
  *ptr++= (unsigned char)state->changed; *ptr++= state->sortkey;
709
709
  mi_rowstore(ptr,state->state.records);        ptr +=8;
710
710
  mi_rowstore(ptr,state->state.del);            ptr +=8;
711
711
  mi_rowstore(ptr,state->split);                ptr +=8;
733
733
  }
734
734
  if (pWrite & 2)                               /* From isamchk */
735
735
  {
736
 
    uint key_parts= mi_uint2korr(state->header.key_parts);
 
736
    uint32_t key_parts= mi_uint2korr(state->header.key_parts);
737
737
    mi_int4store(ptr,state->sec_index_changed); ptr +=4;
738
738
    mi_int4store(ptr,state->sec_index_used);    ptr +=4;
739
739
    mi_int4store(ptr,state->version);           ptr +=4;
756
756
}
757
757
 
758
758
 
759
 
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
 
759
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
760
760
{
761
 
  uint i,keys,key_parts,key_blocks;
 
761
  uint32_t i,keys,key_parts,key_blocks;
762
762
  memcpy(&state->header,ptr, sizeof(state->header));
763
763
  ptr +=sizeof(state->header);
764
764
  keys=(uint) state->header.keys;
809
809
}
810
810
 
811
811
 
812
 
uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
 
812
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
813
813
{
814
 
  uchar buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
814
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
815
815
 
816
816
  if (!myisam_single_user)
817
817
  {
832
832
**  store and read of MI_BASE_INFO
833
833
****************************************************************************/
834
834
 
835
 
uint mi_base_info_write(File file, MI_BASE_INFO *base)
 
835
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
836
836
{
837
 
  uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
 
837
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
838
838
 
839
839
  mi_sizestore(ptr,base->keystart);                     ptr +=8;
840
840
  mi_sizestore(ptr,base->max_data_file_length);         ptr +=8;
859
859
  mi_int2store(ptr,base->max_key_length);               ptr +=2;
860
860
  mi_int2store(ptr,base->extra_alloc_bytes);            ptr +=2;
861
861
  *ptr++= base->extra_alloc_procent;
862
 
  *ptr++= base->raid_type;
863
 
  mi_int2store(ptr,base->raid_chunks);                  ptr +=2;
864
 
  mi_int4store(ptr,base->raid_chunksize);               ptr +=4;
 
862
  /* old raid info  slots */
 
863
  *ptr++= 0;
 
864
  mi_int2store(ptr,UINT16_C(0));                        ptr +=2;
 
865
  mi_int4store(ptr,UINT32_C(0));                        ptr +=4;
 
866
 
865
867
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
866
868
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
867
869
}
868
870
 
869
871
 
870
 
uchar *my_n_base_info_read(uchar *ptr, MI_BASE_INFO *base)
 
872
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
871
873
{
872
874
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
873
875
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
893
895
  base->max_key_length = mi_uint2korr(ptr);             ptr +=2;
894
896
  base->extra_alloc_bytes = mi_uint2korr(ptr);          ptr +=2;
895
897
  base->extra_alloc_procent = *ptr++;
896
 
  base->raid_type= *ptr++;
897
 
  base->raid_chunks= mi_uint2korr(ptr);                 ptr +=2;
898
 
  base->raid_chunksize= mi_uint4korr(ptr);              ptr +=4;
899
 
  /* TO BE REMOVED: Fix for old RAID files */
900
 
  if (base->raid_type == 0)
901
 
  {
902
 
    base->raid_chunks=0;
903
 
    base->raid_chunksize=0;
904
 
  }
 
898
 
 
899
  /* advance past raid_type (1) raid_chunks (2) and raid_chunksize (4) */
 
900
  ptr+= 7;
905
901
 
906
902
  ptr+=6;
907
903
  return ptr;
911
907
  mi_keydef
912
908
---------------------------------------------------------------------------*/
913
909
 
914
 
uint mi_keydef_write(File file, MI_KEYDEF *keydef)
 
910
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
915
911
{
916
 
  uchar buff[MI_KEYDEF_SIZE];
917
 
  uchar *ptr=buff;
 
912
  unsigned char buff[MI_KEYDEF_SIZE];
 
913
  unsigned char *ptr=buff;
918
914
 
919
 
  *ptr++ = (uchar) keydef->keysegs;
 
915
  *ptr++ = (unsigned char) keydef->keysegs;
920
916
  *ptr++ = keydef->key_alg;                     /* Rtree or Btree */
921
917
  mi_int2store(ptr,keydef->flag);               ptr +=2;
922
918
  mi_int2store(ptr,keydef->block_length);       ptr +=2;
926
922
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
927
923
}
928
924
 
929
 
uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef)
 
925
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
930
926
{
931
927
   keydef->keysegs      = (uint) *ptr++;
932
928
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
948
944
 
949
945
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
950
946
{
951
 
  uchar buff[HA_KEYSEG_SIZE];
952
 
  uchar *ptr=buff;
 
947
  unsigned char buff[HA_KEYSEG_SIZE];
 
948
  unsigned char *ptr=buff;
953
949
  ulong pos;
954
950
 
955
951
  *ptr++= keyseg->type;
964
960
  pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
965
961
  mi_int4store(ptr, pos);
966
962
  ptr+=4;
967
 
  
 
963
 
968
964
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
969
965
}
970
966
 
971
967
 
972
 
uchar *mi_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg)
 
968
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
973
969
{
974
970
   keyseg->type         = *ptr++;
975
971
   keyseg->language     = *ptr++;
996
992
  mi_uniquedef
997
993
---------------------------------------------------------------------------*/
998
994
 
999
 
uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
 
995
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
1000
996
{
1001
 
  uchar buff[MI_UNIQUEDEF_SIZE];
1002
 
  uchar *ptr=buff;
 
997
  unsigned char buff[MI_UNIQUEDEF_SIZE];
 
998
  unsigned char *ptr=buff;
1003
999
 
1004
1000
  mi_int2store(ptr,def->keysegs);               ptr+=2;
1005
 
  *ptr++=  (uchar) def->key;
1006
 
  *ptr++ = (uchar) def->null_are_equal;
 
1001
  *ptr++=  (unsigned char) def->key;
 
1002
  *ptr++ = (unsigned char) def->null_are_equal;
1007
1003
 
1008
1004
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1009
1005
}
1010
1006
 
1011
 
uchar *mi_uniquedef_read(uchar *ptr, MI_UNIQUEDEF *def)
 
1007
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1012
1008
{
1013
1009
   def->keysegs = mi_uint2korr(ptr);
1014
1010
   def->key     = ptr[2];
1020
1016
**  MI_COLUMNDEF
1021
1017
***************************************************************************/
1022
1018
 
1023
 
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
 
1019
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1024
1020
{
1025
 
  uchar buff[MI_COLUMNDEF_SIZE];
1026
 
  uchar *ptr=buff;
 
1021
  unsigned char buff[MI_COLUMNDEF_SIZE];
 
1022
  unsigned char *ptr=buff;
1027
1023
 
1028
1024
  mi_int2store(ptr,recinfo->type);      ptr +=2;
1029
1025
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1032
1028
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1033
1029
}
1034
1030
 
1035
 
uchar *mi_recinfo_read(uchar *ptr, MI_COLUMNDEF *recinfo)
 
1031
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1036
1032
{
1037
1033
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1038
1034
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1042
1038
}
1043
1039
 
1044
1040
/**************************************************************************
1045
 
Open data file with or without RAID
 
1041
Open data file
1046
1042
We can't use dup() here as the data file descriptors need to have different
1047
1043
active seek-positions.
1048
1044
 
1050
1046
exist a dup()-like call that would give us two different file descriptors.
1051
1047
*************************************************************************/
1052
1048
 
1053
 
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share,
1054
 
                     File file_to_dup __attribute__((unused)))
 
1049
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup)
1055
1050
{
1056
 
    info->dfile=my_open(share->data_file_name, share->mode | O_SHARE,
1057
 
                        MYF(MY_WME));
 
1051
  (void)file_to_dup; 
 
1052
  info->dfile=my_open(share->data_file_name, share->mode,
 
1053
                      MYF(MY_WME));
1058
1054
  return info->dfile >= 0 ? 0 : 1;
1059
1055
}
1060
1056
 
1061
1057
 
1062
1058
int mi_open_keyfile(MYISAM_SHARE *share)
1063
1059
{
1064
 
  if ((share->kfile=my_open(share->unique_file_name, share->mode | O_SHARE,
 
1060
  if ((share->kfile=my_open(share->unique_file_name, share->mode,
1065
1061
                            MYF(MY_WME))) < 0)
1066
1062
    return 1;
1067
1063
  return 0;