← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_open.c

Merge/fix in FAQ.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_open.c
16
16
/* open a isam-database */
17
17
 
18
18
#include "myisamdef.h"
19
 
#include <mystrings/m_ctype.h>
 
19
#include <m_ctype.h>
20
20
 
21
21
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)
 
22
#define get_next_element(to,pos,size) { memcpy((char*) to,pos,(size_t) size); \
 
23
                                        pos+=size;}
27
24
 
28
25
 
29
26
#define disk_pos_assert(pos, end_pos) \
62
59
  have an open count of 0.
63
60
******************************************************************************/
64
61
 
65
 
MI_INFO *mi_open(const char *name, int mode, uint32_t open_flags)
 
62
MI_INFO *mi_open(const char *name, int mode, uint open_flags)
66
63
{
67
64
  int lock_error,kfile,open_mode,save_errno,have_rtree=0;
68
 
  uint32_t i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
 
65
  uint i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
69
66
    key_parts,unique_key_parts,fulltext_keys,uniques;
70
67
  char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
71
68
       data_name[FN_REFLEN];
72
 
  unsigned char *disk_cache= NULL;
73
 
  unsigned char *disk_pos, *end_pos;
 
69
  uchar *disk_cache, *disk_pos, *end_pos;
74
70
  MI_INFO info,*m_info,*old_info;
75
71
  MYISAM_SHARE share_buff,*share;
76
72
  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];
81
77
  lock_error=1;
82
78
  errpos=0;
83
79
  head_length=sizeof(share_buff.state.header);
84
 
  memset(&info, 0, sizeof(info));
 
80
  bzero((uchar*) &info,sizeof(info));
85
81
 
86
82
  my_realpath(name_buff, fn_format(org_name,name,"",MI_NAME_IEXT,
87
83
                                   MY_UNPACK_FILENAME),MYF(0));
89
85
  if (!(old_info=test_if_reopen(name_buff)))
90
86
  {
91
87
    share= &share_buff;
92
 
    memset(&share_buff, 0, sizeof(share_buff));
 
88
    bzero((uchar*) &share_buff,sizeof(share_buff));
93
89
    share_buff.state.rec_per_key_part=rec_per_key_part;
94
90
    share_buff.state.key_root=key_root;
95
91
    share_buff.state.key_del=key_del;
96
 
    share_buff.key_cache= multi_key_cache_search((unsigned char*) name_buff,
 
92
    share_buff.key_cache= multi_key_cache_search((uchar*) name_buff,
97
93
                                                 strlen(name_buff));
98
94
 
99
95
    if ((kfile=my_open(name_buff,(open_mode=O_RDWR) | O_SHARE,MYF(0))) < 0)
111
107
      my_errno= HA_ERR_NOT_A_TABLE;
112
108
      goto err;
113
109
    }
114
 
    if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
 
110
    if (memcmp((uchar*) share->state.header.file_version,
 
111
               (uchar*) myisam_file_magic, 4))
115
112
    {
116
113
      my_errno=HA_ERR_NOT_A_TABLE;
117
114
      goto err;
136
133
    /* Don't call realpath() if the name can't be a link */
137
134
    if (!strcmp(name_buff, org_name) ||
138
135
        my_readlink(index_name, org_name, MYF(0)) == -1)
139
 
      (void) my_stpcpy(index_name, org_name);
 
136
      (void) strmov(index_name, org_name);
140
137
    *strrchr(org_name, '.')= '\0';
141
138
    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,
142
139
                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);
143
140
 
144
141
    info_length=mi_uint2korr(share->state.header.header_length);
145
142
    base_pos=mi_uint2korr(share->state.header.base_pos);
146
 
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
 
143
    if (!(disk_cache= (uchar*) my_alloca(info_length+128)))
147
144
    {
148
145
      my_errno=ENOMEM;
149
146
      goto err;
151
148
    end_pos=disk_cache+info_length;
152
149
    errpos=2;
153
150
 
154
 
    my_seek(kfile,0L,MY_SEEK_SET,MYF(0));
 
151
    VOID(my_seek(kfile,0L,MY_SEEK_SET,MYF(0)));
155
152
    errpos=3;
156
153
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
157
154
    {
241
238
                         (share->state.header.max_block_size_index*sizeof(my_off_t)),
242
239
                         &share->key_root_lock,sizeof(rw_lock_t)*keys,
243
240
                         &share->mmap_lock,sizeof(rw_lock_t),
244
 
                         NULL))
 
241
                         NullS))
245
242
      goto err;
246
243
    errpos=4;
247
244
    *share=share_buff;
248
 
    memcpy(share->state.rec_per_key_part, rec_per_key_part,
249
 
           sizeof(long)*key_parts);
250
 
    memcpy(share->state.key_root, key_root,
251
 
           sizeof(my_off_t)*keys);
252
 
    memcpy(share->state.key_del, key_del,
253
 
           sizeof(my_off_t) * share->state.header.max_block_size_index);
254
 
    my_stpcpy(share->unique_file_name, name_buff);
 
245
    memcpy((char*) share->state.rec_per_key_part,
 
246
           (char*) rec_per_key_part, sizeof(long)*key_parts);
 
247
    memcpy((char*) share->state.key_root,
 
248
           (char*) key_root, sizeof(my_off_t)*keys);
 
249
    memcpy((char*) share->state.key_del,
 
250
           (char*) key_del, (sizeof(my_off_t) *
 
251
                             share->state.header.max_block_size_index));
 
252
    strmov(share->unique_file_name, name_buff);
255
253
    share->unique_name_length= strlen(name_buff);
256
 
    my_stpcpy(share->index_file_name,  index_name);
257
 
    my_stpcpy(share->data_file_name,   data_name);
 
254
    strmov(share->index_file_name,  index_name);
 
255
    strmov(share->data_file_name,   data_name);
258
256
 
259
 
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
 
257
    share->blocksize=min(IO_SIZE,myisam_block_size);
260
258
    {
261
259
      HA_KEYSEG *pos=share->keyparts;
262
260
      for (i=0 ; i < keys ; i++)
375
373
    share->base.margin_key_file_length=(share->base.max_key_file_length -
376
374
                                        (keys ? MI_INDEX_BLOCK_MARGIN *
377
375
                                         share->blocksize * keys : 0));
378
 
    share->blocksize=cmin(IO_SIZE,myisam_block_size);
 
376
    share->blocksize=min(IO_SIZE,myisam_block_size);
379
377
    share->data_file_type=STATIC_RECORD;
380
 
    if (share->options & HA_OPTION_PACK_RECORD)
 
378
    if (share->options & HA_OPTION_COMPRESS_RECORD)
 
379
    {
 
380
      share->data_file_type = COMPRESSED_RECORD;
 
381
      share->options|= HA_OPTION_READ_ONLY_DATA;
 
382
      info.s=share;
 
383
      if (_mi_read_pack_info(&info,
 
384
                             (bool)
 
385
                             test(!(share->options &
 
386
                                    (HA_OPTION_PACK_RECORD |
 
387
                                     HA_OPTION_TEMP_COMPRESS_RECORD)))))
 
388
        goto err;
 
389
    }
 
390
    else if (share->options & HA_OPTION_PACK_RECORD)
381
391
      share->data_file_type = DYNAMIC_RECORD;
382
 
    free(disk_cache);
383
 
    disk_cache= NULL;
 
392
    my_afree(disk_cache);
384
393
    mi_setup_functions(share);
385
394
    share->is_log_table= false;
386
395
    thr_lock_init(&share->lock);
387
 
    pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST);
 
396
    VOID(pthread_mutex_init(&share->intern_lock,MY_MUTEX_INIT_FAST));
388
397
    for (i=0; i<keys; i++)
389
 
      my_rwlock_init(&share->key_root_lock[i], NULL);
390
 
    my_rwlock_init(&share->mmap_lock, NULL);
 
398
      VOID(my_rwlock_init(&share->key_root_lock[i], NULL));
 
399
    VOID(my_rwlock_init(&share->mmap_lock, NULL));
391
400
    if (!thr_lock_inited)
392
401
    {
393
402
      /* Probably a single threaded program; Don't use concurrent inserts */
442
451
                       &info.first_mbr_key, share->base.max_key_length,
443
452
                       &info.filename,strlen(name)+1,
444
453
                       &info.rtree_recursion_state,have_rtree ? 1024 : 0,
445
 
                       NULL))
 
454
                       NullS))
446
455
    goto err;
447
456
  errpos=6;
448
457
 
449
458
  if (!have_rtree)
450
459
    info.rtree_recursion_state= NULL;
451
460
 
452
 
  my_stpcpy(info.filename,name);
 
461
  strmov(info.filename,name);
453
462
  memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
454
463
  info.lastkey2=info.lastkey+share->base.max_key_length;
455
464
 
498
507
 
499
508
  /* Allocate buffer for one record */
500
509
 
501
 
  /* prerequisites: memset(info, 0) && info->s=share; are met. */
 
510
  /* prerequisites: bzero(info) && info->s=share; are met. */
502
511
  if (!mi_alloc_rec_buff(&info, -1, &info.rec_buff))
503
512
    goto err;
504
 
  memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
 
513
  bzero(info.rec_buff, mi_get_rec_buff_len(&info, info.rec_buff));
505
514
 
506
515
  *m_info=info;
507
516
  thr_lock_data_init(&share->lock,&m_info->lock,(void*) m_info);
509
518
  myisam_open_list=list_add(myisam_open_list,&m_info->open_list);
510
519
 
511
520
  pthread_mutex_unlock(&THR_LOCK_myisam);
 
521
  if (myisam_log_file >= 0)
 
522
  {
 
523
    intern_filename(name_buff,share->index_file_name);
 
524
    _myisam_log(MI_LOG_OPEN, m_info, (uchar*) name_buff, strlen(name_buff));
 
525
  }
512
526
  return(m_info);
513
527
 
514
528
err:
515
 
  if (disk_cache != NULL)
516
 
    free(disk_cache);
517
529
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
518
530
  if ((save_errno == HA_ERR_CRASHED) ||
519
531
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
521
533
    mi_report_error(save_errno, name);
522
534
  switch (errpos) {
523
535
  case 6:
524
 
    free((unsigned char*) m_info);
 
536
    my_free((uchar*) m_info,MYF(0));
525
537
    /* fall through */
526
538
  case 5:
527
 
    my_close(info.dfile,MYF(0));
 
539
    VOID(my_close(info.dfile,MYF(0)));
528
540
    if (old_info)
529
541
      break;                                    /* Don't remove open table */
530
542
    /* fall through */
531
543
  case 4:
532
 
    free((unsigned char*) share);
 
544
    my_free((uchar*) share,MYF(0));
533
545
    /* fall through */
534
546
  case 3:
535
547
    /* fall through */
 
548
  case 2:
 
549
    my_afree(disk_cache);
 
550
    /* fall through */
536
551
  case 1:
537
 
    my_close(kfile,MYF(0));
 
552
    VOID(my_close(kfile,MYF(0)));
538
553
    /* fall through */
539
554
  case 0:
540
555
  default:
546
561
} /* mi_open */
547
562
 
548
563
 
549
 
unsigned char *mi_alloc_rec_buff(MI_INFO *info, ulong length, unsigned char **buf)
 
564
uchar *mi_alloc_rec_buff(MI_INFO *info, ulong length, uchar **buf)
550
565
{
551
 
  uint32_t extra;
552
 
  uint32_t old_length= 0;
 
566
  uint extra;
 
567
  uint32 old_length= 0;
553
568
 
554
569
  if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
555
570
  {
556
 
    unsigned char *newptr = *buf;
 
571
    uchar *newptr = *buf;
557
572
 
558
573
    /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
559
574
    if (length == (ulong) -1)
560
575
    {
561
576
      if (info->s->options & HA_OPTION_COMPRESS_RECORD)
562
 
        length= cmax(info->s->base.pack_reclength, info->s->max_pack_length);
 
577
        length= max(info->s->base.pack_reclength, info->s->max_pack_length);
563
578
      else
564
579
        length= info->s->base.pack_reclength;
565
 
      length= cmax(length, info->s->base.max_key_length);
 
580
      length= max(length, info->s->base.max_key_length);
566
581
      /* Avoid unnecessary realloc */
567
582
      if (newptr && length == old_length)
568
583
        return newptr;
573
588
            MI_REC_BUFF_OFFSET : 0);
574
589
    if (extra && newptr)
575
590
      newptr-= MI_REC_BUFF_OFFSET;
576
 
    if (!(newptr=(unsigned char*) my_realloc((unsigned char*)newptr, length+extra+8,
 
591
    if (!(newptr=(uchar*) my_realloc((uchar*)newptr, length+extra+8,
577
592
                                     MYF(MY_ALLOW_ZERO_PTR))))
578
593
      return newptr;
579
 
    *((uint32_t *) newptr)= (uint32_t) length;
 
594
    *((uint32 *) newptr)= (uint32) length;
580
595
    *buf= newptr+(extra ?  MI_REC_BUFF_OFFSET : 0);
581
596
  }
582
597
  return *buf;
596
611
 
597
612
void mi_setup_functions(register MYISAM_SHARE *share)
598
613
{
599
 
  if (share->options & HA_OPTION_PACK_RECORD)
 
614
  if (share->options & HA_OPTION_COMPRESS_RECORD)
 
615
  {
 
616
    share->read_record=_mi_read_pack_record;
 
617
    share->read_rnd=_mi_read_rnd_pack_record;
 
618
    if (!(share->options & HA_OPTION_TEMP_COMPRESS_RECORD))
 
619
      share->calc_checksum=0;                           /* No checksum */
 
620
    else if (share->options & HA_OPTION_PACK_RECORD)
 
621
      share->calc_checksum= mi_checksum;
 
622
    else
 
623
      share->calc_checksum= mi_static_checksum;
 
624
  }
 
625
  else if (share->options & HA_OPTION_PACK_RECORD)
600
626
  {
601
627
    share->read_record=_mi_read_dynamic_record;
602
628
    share->read_rnd=_mi_read_rnd_dynamic_record;
694
720
   Function to save and store the header in the index file (.MYI)
695
721
*/
696
722
 
697
 
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
 
723
uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite)
698
724
{
699
 
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
700
 
  unsigned char *ptr=buff;
 
725
  uchar  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
726
  uchar *ptr=buff;
701
727
  uint  i, keys= (uint) state->header.keys,
702
728
        key_blocks=state->header.max_block_size_index;
703
729
 
704
 
  memcpy(ptr,&state->header,sizeof(state->header));
 
730
  memcpy_fixed(ptr,&state->header,sizeof(state->header));
705
731
  ptr+=sizeof(state->header);
706
732
 
707
733
  /* open_count must be first because of _mi_mark_file_changed ! */
708
734
  mi_int2store(ptr,state->open_count);          ptr +=2;
709
 
  *ptr++= (unsigned char)state->changed; *ptr++= state->sortkey;
 
735
  *ptr++= (uchar)state->changed; *ptr++= state->sortkey;
710
736
  mi_rowstore(ptr,state->state.records);        ptr +=8;
711
737
  mi_rowstore(ptr,state->state.del);            ptr +=8;
712
738
  mi_rowstore(ptr,state->split);                ptr +=8;
734
760
  }
735
761
  if (pWrite & 2)                               /* From isamchk */
736
762
  {
737
 
    uint32_t key_parts= mi_uint2korr(state->header.key_parts);
 
763
    uint key_parts= mi_uint2korr(state->header.key_parts);
738
764
    mi_int4store(ptr,state->sec_index_changed); ptr +=4;
739
765
    mi_int4store(ptr,state->sec_index_used);    ptr +=4;
740
766
    mi_int4store(ptr,state->version);           ptr +=4;
757
783
}
758
784
 
759
785
 
760
 
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
 
786
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state)
761
787
{
762
 
  uint32_t i,keys,key_parts,key_blocks;
763
 
  memcpy(&state->header,ptr, sizeof(state->header));
 
788
  uint i,keys,key_parts,key_blocks;
 
789
  memcpy_fixed(&state->header,ptr, sizeof(state->header));
764
790
  ptr +=sizeof(state->header);
765
791
  keys=(uint) state->header.keys;
766
792
  key_parts=mi_uint2korr(state->header.key_parts);
810
836
}
811
837
 
812
838
 
813
 
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
 
839
uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead)
814
840
{
815
 
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
 
841
  uchar buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
816
842
 
817
843
  if (!myisam_single_user)
818
844
  {
833
859
**  store and read of MI_BASE_INFO
834
860
****************************************************************************/
835
861
 
836
 
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
 
862
uint mi_base_info_write(File file, MI_BASE_INFO *base)
837
863
{
838
 
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
 
864
  uchar buff[MI_BASE_INFO_SIZE], *ptr=buff;
839
865
 
840
866
  mi_sizestore(ptr,base->keystart);                     ptr +=8;
841
867
  mi_sizestore(ptr,base->max_data_file_length);         ptr +=8;
863
889
  *ptr++= base->raid_type;
864
890
  mi_int2store(ptr,base->raid_chunks);                  ptr +=2;
865
891
  mi_int4store(ptr,base->raid_chunksize);               ptr +=4;
866
 
  memset(ptr, 0, 6);                                    ptr +=6; /* extra */
 
892
  bzero(ptr,6);                                         ptr +=6; /* extra */
867
893
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
868
894
}
869
895
 
870
896
 
871
 
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
 
897
uchar *my_n_base_info_read(uchar *ptr, MI_BASE_INFO *base)
872
898
{
873
899
  base->keystart = mi_sizekorr(ptr);                    ptr +=8;
874
900
  base->max_data_file_length = mi_sizekorr(ptr);        ptr +=8;
912
938
  mi_keydef
913
939
---------------------------------------------------------------------------*/
914
940
 
915
 
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
 
941
uint mi_keydef_write(File file, MI_KEYDEF *keydef)
916
942
{
917
 
  unsigned char buff[MI_KEYDEF_SIZE];
918
 
  unsigned char *ptr=buff;
 
943
  uchar buff[MI_KEYDEF_SIZE];
 
944
  uchar *ptr=buff;
919
945
 
920
 
  *ptr++ = (unsigned char) keydef->keysegs;
 
946
  *ptr++ = (uchar) keydef->keysegs;
921
947
  *ptr++ = keydef->key_alg;                     /* Rtree or Btree */
922
948
  mi_int2store(ptr,keydef->flag);               ptr +=2;
923
949
  mi_int2store(ptr,keydef->block_length);       ptr +=2;
927
953
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
928
954
}
929
955
 
930
 
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
 
956
uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef)
931
957
{
932
958
   keydef->keysegs      = (uint) *ptr++;
933
959
   keydef->key_alg      = *ptr++;               /* Rtree or Btree */
949
975
 
950
976
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
951
977
{
952
 
  unsigned char buff[HA_KEYSEG_SIZE];
953
 
  unsigned char *ptr=buff;
 
978
  uchar buff[HA_KEYSEG_SIZE];
 
979
  uchar *ptr=buff;
954
980
  ulong pos;
955
981
 
956
982
  *ptr++= keyseg->type;
970
996
}
971
997
 
972
998
 
973
 
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
 
999
uchar *mi_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg)
974
1000
{
975
1001
   keyseg->type         = *ptr++;
976
1002
   keyseg->language     = *ptr++;
984
1010
   keyseg->null_pos     = mi_uint4korr(ptr);  ptr +=4;
985
1011
   keyseg->charset=0;                           /* Will be filled in later */
986
1012
   if (keyseg->null_bit)
987
 
     keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
 
1013
     keyseg->bit_pos= (uint16)(keyseg->null_pos + (keyseg->null_bit == 7));
988
1014
   else
989
1015
   {
990
 
     keyseg->bit_pos= (uint16_t)keyseg->null_pos;
 
1016
     keyseg->bit_pos= (uint16)keyseg->null_pos;
991
1017
     keyseg->null_pos= 0;
992
1018
   }
993
1019
   return ptr;
997
1023
  mi_uniquedef
998
1024
---------------------------------------------------------------------------*/
999
1025
 
1000
 
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
 
1026
uint mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
1001
1027
{
1002
 
  unsigned char buff[MI_UNIQUEDEF_SIZE];
1003
 
  unsigned char *ptr=buff;
 
1028
  uchar buff[MI_UNIQUEDEF_SIZE];
 
1029
  uchar *ptr=buff;
1004
1030
 
1005
1031
  mi_int2store(ptr,def->keysegs);               ptr+=2;
1006
 
  *ptr++=  (unsigned char) def->key;
1007
 
  *ptr++ = (unsigned char) def->null_are_equal;
 
1032
  *ptr++=  (uchar) def->key;
 
1033
  *ptr++ = (uchar) def->null_are_equal;
1008
1034
 
1009
1035
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1010
1036
}
1011
1037
 
1012
 
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
 
1038
uchar *mi_uniquedef_read(uchar *ptr, MI_UNIQUEDEF *def)
1013
1039
{
1014
1040
   def->keysegs = mi_uint2korr(ptr);
1015
1041
   def->key     = ptr[2];
1021
1047
**  MI_COLUMNDEF
1022
1048
***************************************************************************/
1023
1049
 
1024
 
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
 
1050
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
1025
1051
{
1026
 
  unsigned char buff[MI_COLUMNDEF_SIZE];
1027
 
  unsigned char *ptr=buff;
 
1052
  uchar buff[MI_COLUMNDEF_SIZE];
 
1053
  uchar *ptr=buff;
1028
1054
 
1029
1055
  mi_int2store(ptr,recinfo->type);      ptr +=2;
1030
1056
  mi_int2store(ptr,recinfo->length);    ptr +=2;
1033
1059
  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1034
1060
}
1035
1061
 
1036
 
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
 
1062
uchar *mi_recinfo_read(uchar *ptr, MI_COLUMNDEF *recinfo)
1037
1063
{
1038
1064
   recinfo->type=  mi_sint2korr(ptr);   ptr +=2;
1039
1065
   recinfo->length=mi_uint2korr(ptr);   ptr +=2;
1040
 
   recinfo->null_bit= (uint8_t) *ptr++;
 
1066
   recinfo->null_bit= (uint8) *ptr++;
1041
1067
   recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1042
1068
   return ptr;
1043
1069
}