← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_open.cc

  • Committer: Stewart Smith
  • Date: 2009-10-08 12:39:27 UTC
  • mto: This revision was merged to the branch mainline in revision 1179.
  • Revision ID: stewart@flamingspork.com-20091008123927-qpf9hog04w4xc5aj
make directory_file_name() static to mysys/my_lib.cc

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_open.cc
15
15
 
16
16
/* open a isam-database */
17
17
 
18
 
#include "myisam_priv.h"
 
18
#include "myisamdef.h"
 
19
#include <mystrings/m_ctype.h>
 
20
#include <mystrings/m_string.h>
 
21
#include <drizzled/util/test.h>
19
22
 
20
23
#include <string.h>
21
24
#include <algorithm>
22
25
 
23
 
#include "drizzled/charset_info.h"
24
 
#include "drizzled/internal/m_string.h"
25
 
#include "drizzled/util/test.h"
26
 
#include "drizzled/global_charset_info.h"
27
 
#include "drizzled/charset.h"
28
 
#include "drizzled/memory/multi_malloc.h"
29
 
 
30
 
 
31
26
using namespace std;
32
 
using namespace drizzled;
33
27
 
34
28
static void setup_key_functions(MI_KEYDEF *keyinfo);
35
 
static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef);
36
 
static unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg);
37
 
static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo);
38
 
static uint64_t mi_safe_mul(uint64_t a, uint64_t b);
39
 
static unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state);
40
 
static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def);
41
 
static unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base);
42
29
 
43
30
#define disk_pos_assert(pos, end_pos) \
44
31
if (pos > end_pos)             \
45
32
{                              \
46
 
  errno=HA_ERR_CRASHED;     \
 
33
  my_errno=HA_ERR_CRASHED;     \
47
34
  goto err;                    \
48
35
}
49
36
 
88
75
  MI_INFO info,*m_info,*old_info;
89
76
  MYISAM_SHARE share_buff,*share;
90
77
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
91
 
  internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
 
78
  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
92
79
  uint64_t max_key_file_length, max_data_file_length;
93
80
 
94
81
  kfile= -1;
97
84
  head_length=sizeof(share_buff.state.header);
98
85
  memset(&info, 0, sizeof(info));
99
86
 
100
 
  (void)internal::fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);
 
87
  (void)fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);
101
88
  if (!realpath(org_name,rp_buff))
102
 
    internal::my_load_path(rp_buff,org_name, NULL);
 
89
    my_load_path(rp_buff,org_name, NULL);
103
90
  rp_buff[FN_REFLEN-1]= '\0';
104
91
  strcpy(name_buff,rp_buff);
105
92
  pthread_mutex_lock(&THR_LOCK_myisam);
112
99
    share_buff.state.key_del=key_del;
113
100
    share_buff.key_cache= dflt_key_cache;
114
101
 
115
 
    if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
 
102
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
116
103
    {
117
104
      if ((errno != EROFS && errno != EACCES) ||
118
105
          mode != O_RDONLY ||
119
 
          (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
 
106
          (kfile=my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
120
107
        goto err;
121
108
    }
122
109
    share->mode=open_mode;
123
110
    errpos=1;
124
 
    if (internal::my_read(kfile, share->state.header.file_version, head_length,
 
111
    if (my_read(kfile, share->state.header.file_version, head_length,
125
112
                MYF(MY_NABP)))
126
113
    {
127
 
      errno= HA_ERR_NOT_A_TABLE;
 
114
      my_errno= HA_ERR_NOT_A_TABLE;
128
115
      goto err;
129
116
    }
130
117
    if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
131
118
    {
132
 
      errno=HA_ERR_NOT_A_TABLE;
 
119
      my_errno=HA_ERR_NOT_A_TABLE;
133
120
      goto err;
134
121
    }
135
122
    share->options= mi_uint2korr(share->state.header.options);
140
127
          HA_OPTION_TMP_TABLE
141
128
          ))
142
129
    {
143
 
      errno=HA_ERR_OLD_FILE;
 
130
      my_errno=HA_ERR_OLD_FILE;
144
131
      goto err;
145
132
    }
146
133
 
151
138
    if (!strcmp(name_buff, org_name) || sym_link_size == -1)
152
139
      (void) strcpy(index_name, org_name);
153
140
    *strrchr(org_name, '.')= '\0';
154
 
    (void) internal::fn_format(data_name,org_name,"",MI_NAME_DEXT,
 
141
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
155
142
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
156
143
 
157
144
    info_length=mi_uint2korr(share->state.header.header_length);
158
145
    base_pos=mi_uint2korr(share->state.header.base_pos);
159
146
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
160
147
    {
161
 
      errno=ENOMEM;
 
148
      my_errno=ENOMEM;
162
149
      goto err;
163
150
    }
164
151
    end_pos=disk_cache+info_length;
166
153
 
167
154
    lseek(kfile,0,SEEK_SET);
168
155
    errpos=3;
169
 
    if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
 
156
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
170
157
    {
171
 
      errno=HA_ERR_CRASHED;
 
158
      my_errno=HA_ERR_CRASHED;
172
159
      goto err;
173
160
    }
174
161
    len=mi_uint2korr(share->state.header.state_info_length);
184
171
    disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
185
172
    share->state.state_length=base_pos;
186
173
 
187
 
    if (share->state.changed & STATE_CRASHED)
 
174
    if (!(open_flags & HA_OPEN_FOR_REPAIR) &&
 
175
        ((share->state.changed & STATE_CRASHED) ||
 
176
         ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
 
177
          (share->state.open_count))))
188
178
    {
189
 
      errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
 
179
      my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
190
180
                HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
191
181
      goto err;
192
182
    }
194
184
    /* sanity check */
195
185
    if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
196
186
    {
197
 
      errno=HA_ERR_CRASHED;
 
187
      my_errno=HA_ERR_CRASHED;
198
188
      goto err;
199
189
    }
200
190
 
201
191
    if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
202
192
        key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
203
193
    {
204
 
      errno=HA_ERR_UNSUPPORTED;
 
194
      my_errno=HA_ERR_UNSUPPORTED;
205
195
      goto err;
206
196
    }
207
197
 
220
210
#endif
221
211
    if (share->base.raid_type)
222
212
    {
223
 
      errno=HA_ERR_UNSUPPORTED;
 
213
      my_errno=HA_ERR_UNSUPPORTED;
224
214
      goto err;
225
215
    }
226
 
    share->base.max_data_file_length=(internal::my_off_t) max_data_file_length;
227
 
    share->base.max_key_file_length=(internal::my_off_t) max_key_file_length;
 
216
    share->base.max_data_file_length=(my_off_t) max_data_file_length;
 
217
    share->base.max_key_file_length=(my_off_t) max_key_file_length;
228
218
 
229
219
    if (share->options & HA_OPTION_COMPRESS_RECORD)
230
220
      share->base.max_key_length+=2;    /* For safety */
232
222
    /* Add space for node pointer */
233
223
    share->base.max_key_length+= share->base.key_reflength;
234
224
 
235
 
    if (!drizzled::memory::multi_malloc(false,
236
 
           &share,sizeof(*share),
237
 
           &share->state.rec_per_key_part,sizeof(long)*key_parts,
238
 
           &share->keyinfo,keys*sizeof(MI_KEYDEF),
239
 
           &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
240
 
           &share->keyparts,
241
 
           (key_parts+unique_key_parts+keys+uniques) * sizeof(HA_KEYSEG),
242
 
           &share->rec, (share->base.fields+1)*sizeof(MI_COLUMNDEF),
243
 
           &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
244
 
           &share->unique_file_name,strlen(name_buff)+1,
245
 
           &share->index_file_name,strlen(index_name)+1,
246
 
           &share->data_file_name,strlen(data_name)+1,
247
 
           &share->state.key_root,keys*sizeof(uint64_t),
248
 
           &share->state.key_del,
249
 
           (share->state.header.max_block_size_index*sizeof(uint64_t)),
250
 
           &share->key_root_lock,sizeof(pthread_rwlock_t)*keys,
251
 
           &share->mmap_lock,sizeof(pthread_rwlock_t),
252
 
           NULL))
 
225
    if (!my_multi_malloc(MY_WME,
 
226
                         &share,sizeof(*share),
 
227
                         &share->state.rec_per_key_part,sizeof(long)*key_parts,
 
228
                         &share->keyinfo,keys*sizeof(MI_KEYDEF),
 
229
                         &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
 
230
                         &share->keyparts,
 
231
                         (key_parts+unique_key_parts+keys+uniques) *
 
232
                         sizeof(HA_KEYSEG),
 
233
                         &share->rec,
 
234
                         (share->base.fields+1)*sizeof(MI_COLUMNDEF),
 
235
                         &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
 
236
                         &share->unique_file_name,strlen(name_buff)+1,
 
237
                         &share->index_file_name,strlen(index_name)+1,
 
238
                         &share->data_file_name,strlen(data_name)+1,
 
239
                         &share->state.key_root,keys*sizeof(my_off_t),
 
240
                         &share->state.key_del,
 
241
                         (share->state.header.max_block_size_index*sizeof(my_off_t)),
 
242
                         &share->key_root_lock,sizeof(pthread_rwlock_t)*keys,
 
243
                         &share->mmap_lock,sizeof(pthread_rwlock_t),
 
244
                         NULL))
253
245
      goto err;
254
246
    errpos=4;
255
247
    *share=share_buff;
256
248
    memcpy(share->state.rec_per_key_part, rec_per_key_part,
257
249
           sizeof(long)*key_parts);
258
250
    memcpy(share->state.key_root, key_root,
259
 
           sizeof(internal::my_off_t)*keys);
 
251
           sizeof(my_off_t)*keys);
260
252
    memcpy(share->state.key_del, key_del,
261
 
           sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
 
253
           sizeof(my_off_t) * share->state.header.max_block_size_index);
262
254
    strcpy(share->unique_file_name, name_buff);
263
255
    share->unique_name_length= strlen(name_buff);
264
256
    strcpy(share->index_file_name,  index_name);
282
274
              ! (share->options & (HA_OPTION_COMPRESS_RECORD |
283
275
                                   HA_OPTION_PACK_RECORD)))
284
276
          {
285
 
            errno= HA_ERR_CRASHED;
 
277
            my_errno= HA_ERR_CRASHED;
286
278
            goto err;
287
279
          }
288
280
          if (pos->type == HA_KEYTYPE_TEXT ||
293
285
              pos->charset=default_charset_info;
294
286
            else if (!(pos->charset= get_charset(pos->language)))
295
287
            {
296
 
              errno=HA_ERR_UNKNOWN_CHARSET;
 
288
              my_errno=HA_ERR_UNKNOWN_CHARSET;
297
289
              goto err;
298
290
            }
299
291
          }
325
317
              pos->charset=default_charset_info;
326
318
            else if (!(pos->charset= get_charset(pos->language)))
327
319
            {
328
 
              errno=HA_ERR_UNKNOWN_CHARSET;
 
320
              my_errno=HA_ERR_UNKNOWN_CHARSET;
329
321
              goto err;
330
322
            }
331
323
          }
357
349
    share->rec[i].type=(int) FIELD_LAST;        /* End marker */
358
350
    if (offset > share->base.reclength)
359
351
    {
360
 
      errno= HA_ERR_CRASHED;
 
352
      my_errno= HA_ERR_CRASHED;
361
353
      goto err;
362
354
    }
363
355
 
421
413
    share= old_info->s;
422
414
    if (mode == O_RDWR && share->mode == O_RDONLY)
423
415
    {
424
 
      errno=EACCES;                             /* Can't open in write mode */
 
416
      my_errno=EACCES;                          /* Can't open in write mode */
425
417
      goto err;
426
418
    }
427
419
    if (mi_open_datafile(&info, share, old_info->dfile))
431
423
  }
432
424
 
433
425
  /* alloc and set up private structure parts */
434
 
  if (!drizzled::memory::multi_malloc(MY_WME,
435
 
         &m_info,sizeof(MI_INFO),
436
 
         &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
437
 
         &info.buff,(share->base.max_key_block_length*2+
438
 
                     share->base.max_key_length),
439
 
         &info.lastkey,share->base.max_key_length*3+1,
440
 
         &info.first_mbr_key, share->base.max_key_length,
441
 
         &info.filename,strlen(name)+1,
442
 
         &info.rtree_recursion_state,have_rtree ? 1024 : 0,
443
 
         NULL))
 
426
  if (!my_multi_malloc(MY_WME,
 
427
                       &m_info,sizeof(MI_INFO),
 
428
                       &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
 
429
                       &info.buff,(share->base.max_key_block_length*2+
 
430
                                   share->base.max_key_length),
 
431
                       &info.lastkey,share->base.max_key_length*3+1,
 
432
                       &info.first_mbr_key, share->base.max_key_length,
 
433
                       &info.filename,strlen(name)+1,
 
434
                       &info.rtree_recursion_state,have_rtree ? 1024 : 0,
 
435
                       NULL))
444
436
    goto err;
445
437
  errpos=6;
446
438
 
517
509
err:
518
510
  if (disk_cache != NULL)
519
511
    free(disk_cache);
520
 
  save_errno=errno ? errno : HA_ERR_END_OF_FILE;
 
512
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
521
513
  if ((save_errno == HA_ERR_CRASHED) ||
522
514
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
523
515
      (save_errno == HA_ERR_CRASHED_ON_REPAIR))
527
519
    free((unsigned char*) m_info);
528
520
    /* fall through */
529
521
  case 5:
530
 
    internal::my_close(info.dfile,MYF(0));
 
522
    my_close(info.dfile,MYF(0));
531
523
    if (old_info)
532
524
      break;                                    /* Don't remove open table */
533
525
    /* fall through */
537
529
  case 3:
538
530
    /* fall through */
539
531
  case 1:
540
 
    internal::my_close(kfile,MYF(0));
 
532
    my_close(kfile,MYF(0));
541
533
    /* fall through */
542
534
  case 0:
543
535
  default:
544
536
    break;
545
537
  }
546
538
  pthread_mutex_unlock(&THR_LOCK_myisam);
547
 
  errno=save_errno;
 
539
  my_errno=save_errno;
548
540
  return (NULL);
549
541
} /* mi_open */
550
542
 
587
579
}
588
580
 
589
581
 
590
 
static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
 
582
uint64_t mi_safe_mul(uint64_t a, uint64_t b)
591
583
{
592
 
  uint64_t max_val= ~ (uint64_t) 0;             /* internal::my_off_t is unsigned */
 
584
  uint64_t max_val= ~ (uint64_t) 0;             /* my_off_t is unsigned */
593
585
 
594
586
  if (!a || max_val / a < b)
595
587
    return max_val;
696
688
   Function to save and store the header in the index file (.MYI)
697
689
*/
698
690
 
699
 
uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite)
 
691
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
700
692
{
701
693
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
702
694
  unsigned char *ptr=buff;
754
746
  if (pWrite & 1)
755
747
    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
756
748
                          MYF(MY_NABP | MY_THREADSAFE)) != 0);
757
 
  return(internal::my_write(file, buff, (size_t) (ptr-buff),
 
749
  return(my_write(file, buff, (size_t) (ptr-buff),
758
750
                       MYF(MY_NABP)) != 0);
759
751
}
760
752
 
761
753
 
762
 
static unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
 
754
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
763
755
{
764
756
  uint32_t i,keys,key_parts,key_blocks;
765
757
  memcpy(&state->header,ptr, sizeof(state->header));
780
772
  state->state.empty    = mi_sizekorr(ptr);     ptr +=8;
781
773
  state->state.key_empty= mi_sizekorr(ptr);     ptr +=8;
782
774
  state->auto_increment=mi_uint8korr(ptr);      ptr +=8;
783
 
  state->state.checksum=(internal::ha_checksum) mi_uint8korr(ptr);      ptr +=8;
 
775
  state->state.checksum=(ha_checksum) mi_uint8korr(ptr);        ptr +=8;
784
776
  state->process= mi_uint4korr(ptr);            ptr +=4;
785
777
  state->unique = mi_uint4korr(ptr);            ptr +=4;
786
778
  state->status = mi_uint4korr(ptr);            ptr +=4;
812
804
}
813
805
 
814
806
 
815
 
uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead)
 
807
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
816
808
{
817
809
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
818
810
 
821
813
    if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
822
814
      return 1;
823
815
  }
824
 
  else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
 
816
  else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))
825
817
    return 1;
826
818
  mi_state_info_read(buff, state);
827
819
 
833
825
**  store and read of MI_BASE_INFO
834
826
****************************************************************************/
835
827
 
836
 
uint32_t mi_base_info_write(int file, MI_BASE_INFO *base)
 
828
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
837
829
{
838
830
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
839
831
 
866
858
  mi_int4store(ptr,UINT32_C(0));                        ptr +=4;
867
859
 
868
860
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
869
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
861
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
870
862
}
871
863
 
872
864
 
873
 
static unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
 
865
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
874
866
{
875
867
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
876
868
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
908
900
  mi_keydef
909
901
---------------------------------------------------------------------------*/
910
902
 
911
 
uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef)
 
903
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
912
904
{
913
905
  unsigned char buff[MI_KEYDEF_SIZE];
914
906
  unsigned char *ptr=buff;
920
912
  mi_int2store(ptr,keydef->keylength);          ptr +=2;
921
913
  mi_int2store(ptr,keydef->minlength);          ptr +=2;
922
914
  mi_int2store(ptr,keydef->maxlength);          ptr +=2;
923
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
915
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
924
916
}
925
917
 
926
 
static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
 
918
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
927
919
{
928
920
   keydef->keysegs      = (uint) *ptr++;
929
921
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
943
935
**  mi_keyseg
944
936
***************************************************************************/
945
937
 
946
 
int mi_keyseg_write(int file, const HA_KEYSEG *keyseg)
 
938
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
947
939
{
948
940
  unsigned char buff[HA_KEYSEG_SIZE];
949
941
  unsigned char *ptr=buff;
962
954
  mi_int4store(ptr, pos);
963
955
  ptr+=4;
964
956
 
965
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
957
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
966
958
}
967
959
 
968
960
 
969
 
static unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
 
961
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
970
962
{
971
963
   keyseg->type         = *ptr++;
972
964
   keyseg->language     = *ptr++;
993
985
  mi_uniquedef
994
986
---------------------------------------------------------------------------*/
995
987
 
996
 
uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *def)
 
988
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
997
989
{
998
990
  unsigned char buff[MI_UNIQUEDEF_SIZE];
999
991
  unsigned char *ptr=buff;
1002
994
  *ptr++=  (unsigned char) def->key;
1003
995
  *ptr++ = (unsigned char) def->null_are_equal;
1004
996
 
1005
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
997
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1006
998
}
1007
999
 
1008
 
static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
 
1000
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1009
1001
{
1010
1002
   def->keysegs = mi_uint2korr(ptr);
1011
1003
   def->key     = ptr[2];
1017
1009
**  MI_COLUMNDEF
1018
1010
***************************************************************************/
1019
1011
 
1020
 
uint32_t mi_recinfo_write(int file, MI_COLUMNDEF *recinfo)
 
1012
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1021
1013
{
1022
1014
  unsigned char buff[MI_COLUMNDEF_SIZE];
1023
1015
  unsigned char *ptr=buff;
1026
1018
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1027
1019
  *ptr++ = recinfo->null_bit;
1028
1020
  mi_int2store(ptr,recinfo->null_pos);  ptr+= 2;
1029
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
1021
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1030
1022
}
1031
1023
 
1032
 
static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
 
1024
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1033
1025
{
1034
1026
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1035
1027
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1047
1039
exist a dup()-like call that would give us two different file descriptors.
1048
1040
*************************************************************************/
1049
1041
 
1050
 
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)
 
1042
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup)
1051
1043
{
1052
1044
  (void)file_to_dup; 
1053
 
  info->dfile=internal::my_open(share->data_file_name, share->mode,
 
1045
  info->dfile=my_open(share->data_file_name, share->mode,
1054
1046
                      MYF(MY_WME));
1055
1047
  return info->dfile >= 0 ? 0 : 1;
1056
1048
}
1058
1050
 
1059
1051
int mi_open_keyfile(MYISAM_SHARE *share)
1060
1052
{
1061
 
  if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
 
1053
  if ((share->kfile=my_open(share->unique_file_name, share->mode,
1062
1054
                            MYF(MY_WME))) < 0)
1063
1055
    return 1;
1064
1056
  return 0;