← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_open.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-08-08 04:22:33 UTC
  • mto: (1115.3.4 captain)
  • mto: This revision was merged to the branch mainline in revision 1117.
  • Revision ID: osullivan.padraig@gmail.com-20090808042233-q0z88zc490z3f3r7
Renamed the Command class to be Statement. Renamed the command directory to
statement and also the command header file to statement. Updated various
source files to reflect this renaming.

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);
136
123
    if (share->options &
137
124
        ~(HA_OPTION_PACK_RECORD | HA_OPTION_PACK_KEYS |
138
125
          HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
139
 
          HA_OPTION_TEMP_COMPRESS_RECORD |
140
 
          HA_OPTION_TMP_TABLE
141
 
          ))
142
 
    {
143
 
      errno=HA_ERR_OLD_FILE;
144
 
      goto err;
145
 
    }
146
 
 
 
126
          HA_OPTION_TEMP_COMPRESS_RECORD | HA_OPTION_CHECKSUM |
 
127
          HA_OPTION_TMP_TABLE | HA_OPTION_DELAY_KEY_WRITE |
 
128
          HA_OPTION_RELIES_ON_SQL_LAYER))
 
129
    {
 
130
      my_errno=HA_ERR_OLD_FILE;
 
131
      goto err;
 
132
    }
 
133
    if ((share->options & HA_OPTION_RELIES_ON_SQL_LAYER) &&
 
134
        ! (open_flags & HA_OPEN_FROM_SQL_LAYER))
 
135
    {
 
136
      my_errno= HA_ERR_UNSUPPORTED;
 
137
      goto err;
 
138
    }
147
139
    /* Don't call realpath() if the name can't be a link */
148
140
    ssize_t sym_link_size= readlink(org_name,index_name,FN_REFLEN-1);
149
141
    if (sym_link_size >= 0 )
151
143
    if (!strcmp(name_buff, org_name) || sym_link_size == -1)
152
144
      (void) strcpy(index_name, org_name);
153
145
    *strrchr(org_name, '.')= '\0';
154
 
    (void) internal::fn_format(data_name,org_name,"",MI_NAME_DEXT,
 
146
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
155
147
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
156
148
 
157
149
    info_length=mi_uint2korr(share->state.header.header_length);
158
150
    base_pos=mi_uint2korr(share->state.header.base_pos);
159
151
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
160
152
    {
161
 
      errno=ENOMEM;
 
153
      my_errno=ENOMEM;
162
154
      goto err;
163
155
    }
164
156
    end_pos=disk_cache+info_length;
166
158
 
167
159
    lseek(kfile,0,SEEK_SET);
168
160
    errpos=3;
169
 
    if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
 
161
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
170
162
    {
171
 
      errno=HA_ERR_CRASHED;
 
163
      my_errno=HA_ERR_CRASHED;
172
164
      goto err;
173
165
    }
174
166
    len=mi_uint2korr(share->state.header.state_info_length);
184
176
    disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
185
177
    share->state.state_length=base_pos;
186
178
 
187
 
    if (share->state.changed & STATE_CRASHED)
 
179
    if (!(open_flags & HA_OPEN_FOR_REPAIR) &&
 
180
        ((share->state.changed & STATE_CRASHED) ||
 
181
         ((open_flags & HA_OPEN_ABORT_IF_CRASHED) &&
 
182
          (share->state.open_count))))
188
183
    {
189
 
      errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
 
184
      my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
190
185
                HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
191
186
      goto err;
192
187
    }
194
189
    /* sanity check */
195
190
    if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
196
191
    {
197
 
      errno=HA_ERR_CRASHED;
 
192
      my_errno=HA_ERR_CRASHED;
198
193
      goto err;
199
194
    }
200
195
 
201
196
    if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
202
197
        key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
203
198
    {
204
 
      errno=HA_ERR_UNSUPPORTED;
 
199
      my_errno=HA_ERR_UNSUPPORTED;
205
200
      goto err;
206
201
    }
207
202
 
220
215
#endif
221
216
    if (share->base.raid_type)
222
217
    {
223
 
      errno=HA_ERR_UNSUPPORTED;
 
218
      my_errno=HA_ERR_UNSUPPORTED;
224
219
      goto err;
225
220
    }
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;
 
221
    share->base.max_data_file_length=(my_off_t) max_data_file_length;
 
222
    share->base.max_key_file_length=(my_off_t) max_key_file_length;
228
223
 
229
224
    if (share->options & HA_OPTION_COMPRESS_RECORD)
230
225
      share->base.max_key_length+=2;    /* For safety */
232
227
    /* Add space for node pointer */
233
228
    share->base.max_key_length+= share->base.key_reflength;
234
229
 
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))
 
230
    if (!my_multi_malloc(MY_WME,
 
231
                         &share,sizeof(*share),
 
232
                         &share->state.rec_per_key_part,sizeof(long)*key_parts,
 
233
                         &share->keyinfo,keys*sizeof(MI_KEYDEF),
 
234
                         &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
 
235
                         &share->keyparts,
 
236
                         (key_parts+unique_key_parts+keys+uniques) *
 
237
                         sizeof(HA_KEYSEG),
 
238
                         &share->rec,
 
239
                         (share->base.fields+1)*sizeof(MI_COLUMNDEF),
 
240
                         &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
 
241
                         &share->unique_file_name,strlen(name_buff)+1,
 
242
                         &share->index_file_name,strlen(index_name)+1,
 
243
                         &share->data_file_name,strlen(data_name)+1,
 
244
                         &share->state.key_root,keys*sizeof(my_off_t),
 
245
                         &share->state.key_del,
 
246
                         (share->state.header.max_block_size_index*sizeof(my_off_t)),
 
247
                         &share->key_root_lock,sizeof(pthread_rwlock_t)*keys,
 
248
                         &share->mmap_lock,sizeof(pthread_rwlock_t),
 
249
                         NULL))
253
250
      goto err;
254
251
    errpos=4;
255
252
    *share=share_buff;
256
253
    memcpy(share->state.rec_per_key_part, rec_per_key_part,
257
254
           sizeof(long)*key_parts);
258
255
    memcpy(share->state.key_root, key_root,
259
 
           sizeof(internal::my_off_t)*keys);
 
256
           sizeof(my_off_t)*keys);
260
257
    memcpy(share->state.key_del, key_del,
261
 
           sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
 
258
           sizeof(my_off_t) * share->state.header.max_block_size_index);
262
259
    strcpy(share->unique_file_name, name_buff);
263
260
    share->unique_name_length= strlen(name_buff);
264
261
    strcpy(share->index_file_name,  index_name);
282
279
              ! (share->options & (HA_OPTION_COMPRESS_RECORD |
283
280
                                   HA_OPTION_PACK_RECORD)))
284
281
          {
285
 
            errno= HA_ERR_CRASHED;
 
282
            my_errno= HA_ERR_CRASHED;
286
283
            goto err;
287
284
          }
288
285
          if (pos->type == HA_KEYTYPE_TEXT ||
293
290
              pos->charset=default_charset_info;
294
291
            else if (!(pos->charset= get_charset(pos->language)))
295
292
            {
296
 
              errno=HA_ERR_UNKNOWN_CHARSET;
 
293
              my_errno=HA_ERR_UNKNOWN_CHARSET;
297
294
              goto err;
298
295
            }
299
296
          }
325
322
              pos->charset=default_charset_info;
326
323
            else if (!(pos->charset= get_charset(pos->language)))
327
324
            {
328
 
              errno=HA_ERR_UNKNOWN_CHARSET;
 
325
              my_errno=HA_ERR_UNKNOWN_CHARSET;
329
326
              goto err;
330
327
            }
331
328
          }
357
354
    share->rec[i].type=(int) FIELD_LAST;        /* End marker */
358
355
    if (offset > share->base.reclength)
359
356
    {
360
 
      errno= HA_ERR_CRASHED;
 
357
      /* purecov: begin inspected */
 
358
      my_errno= HA_ERR_CRASHED;
361
359
      goto err;
 
360
      /* purecov: end */
362
361
    }
363
362
 
364
363
    if (! lock_error)
421
420
    share= old_info->s;
422
421
    if (mode == O_RDWR && share->mode == O_RDONLY)
423
422
    {
424
 
      errno=EACCES;                             /* Can't open in write mode */
 
423
      my_errno=EACCES;                          /* Can't open in write mode */
425
424
      goto err;
426
425
    }
427
426
    if (mi_open_datafile(&info, share, old_info->dfile))
431
430
  }
432
431
 
433
432
  /* 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))
 
433
  if (!my_multi_malloc(MY_WME,
 
434
                       &m_info,sizeof(MI_INFO),
 
435
                       &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
 
436
                       &info.buff,(share->base.max_key_block_length*2+
 
437
                                   share->base.max_key_length),
 
438
                       &info.lastkey,share->base.max_key_length*3+1,
 
439
                       &info.first_mbr_key, share->base.max_key_length,
 
440
                       &info.filename,strlen(name)+1,
 
441
                       &info.rtree_recursion_state,have_rtree ? 1024 : 0,
 
442
                       NULL))
444
443
    goto err;
445
444
  errpos=6;
446
445
 
495
494
//    share->tot_locks++;
496
495
    info.lock_type=F_WRLCK;
497
496
  }
498
 
 
499
 
  share->delay_key_write= 1;
 
497
  if (((open_flags & HA_OPEN_DELAY_KEY_WRITE) ||
 
498
      (share->options & HA_OPTION_DELAY_KEY_WRITE)) &&
 
499
      myisam_delay_key_write)
 
500
    share->delay_key_write=1;
500
501
  info.state= &share->state.state;      /* Change global values by default */
501
502
  pthread_mutex_unlock(&share->intern_lock);
502
503
 
517
518
err:
518
519
  if (disk_cache != NULL)
519
520
    free(disk_cache);
520
 
  save_errno=errno ? errno : HA_ERR_END_OF_FILE;
 
521
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
521
522
  if ((save_errno == HA_ERR_CRASHED) ||
522
523
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
523
524
      (save_errno == HA_ERR_CRASHED_ON_REPAIR))
527
528
    free((unsigned char*) m_info);
528
529
    /* fall through */
529
530
  case 5:
530
 
    internal::my_close(info.dfile,MYF(0));
 
531
    my_close(info.dfile,MYF(0));
531
532
    if (old_info)
532
533
      break;                                    /* Don't remove open table */
533
534
    /* fall through */
537
538
  case 3:
538
539
    /* fall through */
539
540
  case 1:
540
 
    internal::my_close(kfile,MYF(0));
 
541
    my_close(kfile,MYF(0));
541
542
    /* fall through */
542
543
  case 0:
543
544
  default:
544
545
    break;
545
546
  }
546
547
  pthread_mutex_unlock(&THR_LOCK_myisam);
547
 
  errno=save_errno;
 
548
  my_errno=save_errno;
548
549
  return (NULL);
549
550
} /* mi_open */
550
551
 
587
588
}
588
589
 
589
590
 
590
 
static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
 
591
uint64_t mi_safe_mul(uint64_t a, uint64_t b)
591
592
{
592
 
  uint64_t max_val= ~ (uint64_t) 0;             /* internal::my_off_t is unsigned */
 
593
  uint64_t max_val= ~ (uint64_t) 0;             /* my_off_t is unsigned */
593
594
 
594
595
  if (!a || max_val / a < b)
595
596
    return max_val;
635
636
  }
636
637
  share->file_read= mi_nommap_pread;
637
638
  share->file_write= mi_nommap_pwrite;
638
 
  share->calc_checksum=0;
 
639
  if (!(share->options & HA_OPTION_CHECKSUM))
 
640
    share->calc_checksum=0;
 
641
  return;
639
642
}
640
643
 
641
644
 
696
699
   Function to save and store the header in the index file (.MYI)
697
700
*/
698
701
 
699
 
uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite)
 
702
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
700
703
{
701
704
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
702
705
  unsigned char *ptr=buff;
754
757
  if (pWrite & 1)
755
758
    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
756
759
                          MYF(MY_NABP | MY_THREADSAFE)) != 0);
757
 
  return(internal::my_write(file, buff, (size_t) (ptr-buff),
 
760
  return(my_write(file, buff, (size_t) (ptr-buff),
758
761
                       MYF(MY_NABP)) != 0);
759
762
}
760
763
 
761
764
 
762
 
static unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
 
765
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
763
766
{
764
767
  uint32_t i,keys,key_parts,key_blocks;
765
768
  memcpy(&state->header,ptr, sizeof(state->header));
780
783
  state->state.empty    = mi_sizekorr(ptr);     ptr +=8;
781
784
  state->state.key_empty= mi_sizekorr(ptr);     ptr +=8;
782
785
  state->auto_increment=mi_uint8korr(ptr);      ptr +=8;
783
 
  state->state.checksum=(internal::ha_checksum) mi_uint8korr(ptr);      ptr +=8;
 
786
  state->state.checksum=(ha_checksum) mi_uint8korr(ptr);        ptr +=8;
784
787
  state->process= mi_uint4korr(ptr);            ptr +=4;
785
788
  state->unique = mi_uint4korr(ptr);            ptr +=4;
786
789
  state->status = mi_uint4korr(ptr);            ptr +=4;
812
815
}
813
816
 
814
817
 
815
 
uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead)
 
818
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
816
819
{
817
820
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
818
821
 
819
 
  if (pRead)
 
822
  if (!myisam_single_user)
820
823
  {
821
 
    if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
 
824
    if (pRead)
 
825
    {
 
826
      if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
 
827
        return 1;
 
828
    }
 
829
    else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))
822
830
      return 1;
 
831
    mi_state_info_read(buff, state);
823
832
  }
824
 
  else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
825
 
    return 1;
826
 
  mi_state_info_read(buff, state);
827
 
 
828
833
  return 0;
829
834
}
830
835
 
833
838
**  store and read of MI_BASE_INFO
834
839
****************************************************************************/
835
840
 
836
 
uint32_t mi_base_info_write(int file, MI_BASE_INFO *base)
 
841
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
837
842
{
838
843
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
839
844
 
866
871
  mi_int4store(ptr,UINT32_C(0));                        ptr +=4;
867
872
 
868
873
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
869
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
874
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
870
875
}
871
876
 
872
877
 
873
 
static unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
 
878
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
874
879
{
875
880
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
876
881
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
908
913
  mi_keydef
909
914
---------------------------------------------------------------------------*/
910
915
 
911
 
uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef)
 
916
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
912
917
{
913
918
  unsigned char buff[MI_KEYDEF_SIZE];
914
919
  unsigned char *ptr=buff;
920
925
  mi_int2store(ptr,keydef->keylength);          ptr +=2;
921
926
  mi_int2store(ptr,keydef->minlength);          ptr +=2;
922
927
  mi_int2store(ptr,keydef->maxlength);          ptr +=2;
923
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
928
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
924
929
}
925
930
 
926
 
static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
 
931
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
927
932
{
928
933
   keydef->keysegs      = (uint) *ptr++;
929
934
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
943
948
**  mi_keyseg
944
949
***************************************************************************/
945
950
 
946
 
int mi_keyseg_write(int file, const HA_KEYSEG *keyseg)
 
951
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
947
952
{
948
953
  unsigned char buff[HA_KEYSEG_SIZE];
949
954
  unsigned char *ptr=buff;
962
967
  mi_int4store(ptr, pos);
963
968
  ptr+=4;
964
969
 
965
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
970
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
966
971
}
967
972
 
968
973
 
969
 
static unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
 
974
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
970
975
{
971
976
   keyseg->type         = *ptr++;
972
977
   keyseg->language     = *ptr++;
993
998
  mi_uniquedef
994
999
---------------------------------------------------------------------------*/
995
1000
 
996
 
uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *def)
 
1001
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
997
1002
{
998
1003
  unsigned char buff[MI_UNIQUEDEF_SIZE];
999
1004
  unsigned char *ptr=buff;
1002
1007
  *ptr++=  (unsigned char) def->key;
1003
1008
  *ptr++ = (unsigned char) def->null_are_equal;
1004
1009
 
1005
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
1010
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1006
1011
}
1007
1012
 
1008
 
static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
 
1013
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1009
1014
{
1010
1015
   def->keysegs = mi_uint2korr(ptr);
1011
1016
   def->key     = ptr[2];
1017
1022
**  MI_COLUMNDEF
1018
1023
***************************************************************************/
1019
1024
 
1020
 
uint32_t mi_recinfo_write(int file, MI_COLUMNDEF *recinfo)
 
1025
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1021
1026
{
1022
1027
  unsigned char buff[MI_COLUMNDEF_SIZE];
1023
1028
  unsigned char *ptr=buff;
1026
1031
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1027
1032
  *ptr++ = recinfo->null_bit;
1028
1033
  mi_int2store(ptr,recinfo->null_pos);  ptr+= 2;
1029
 
  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
 
1034
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1030
1035
}
1031
1036
 
1032
 
static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
 
1037
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1033
1038
{
1034
1039
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1035
1040
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1047
1052
exist a dup()-like call that would give us two different file descriptors.
1048
1053
*************************************************************************/
1049
1054
 
1050
 
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)
 
1055
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup)
1051
1056
{
1052
1057
  (void)file_to_dup; 
1053
 
  info->dfile=internal::my_open(share->data_file_name, share->mode,
 
1058
  info->dfile=my_open(share->data_file_name, share->mode,
1054
1059
                      MYF(MY_WME));
1055
1060
  return info->dfile >= 0 ? 0 : 1;
1056
1061
}
1058
1063
 
1059
1064
int mi_open_keyfile(MYISAM_SHARE *share)
1060
1065
{
1061
 
  if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
 
1066
  if ((share->kfile=my_open(share->unique_file_name, share->mode,
1062
1067
                            MYF(MY_WME))) < 0)
1063
1068
    return 1;
1064
1069
  return 0;