← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_check.c

  • Committer: Brian Aker
  • Date: 2008-10-06 06:47:29 UTC
  • Revision ID: brian@tangent.org-20081006064729-2i9mhjkzyvow9xsm
Remove uint.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_check.c
60
60
 
61
61
        /* Functions defined in this file */
62
62
 
63
 
static int check_k_link(MI_CHECK *param, MI_INFO *info,uint nr);
 
63
static int check_k_link(MI_CHECK *param, MI_INFO *info,uint32_t nr);
64
64
static int chk_index(MI_CHECK *param, MI_INFO *info,MI_KEYDEF *keyinfo,
65
65
                     my_off_t page, unsigned char *buff, ha_rows *keys,
66
 
                     ha_checksum *key_checksum, uint level);
67
 
static uint isam_key_length(MI_INFO *info,MI_KEYDEF *keyinfo);
 
66
                     ha_checksum *key_checksum, uint32_t level);
 
67
static uint32_t isam_key_length(MI_INFO *info,MI_KEYDEF *keyinfo);
68
68
static ha_checksum calc_checksum(ha_rows count);
69
69
static int writekeys(MI_SORT_PARAM *sort_param);
70
70
static int sort_one_index(MI_CHECK *param, MI_INFO *info,MI_KEYDEF *keyinfo,
80
80
                           unsigned char *key, my_off_t prev_block);
81
81
static int sort_delete_record(MI_SORT_PARAM *sort_param);
82
82
/*static int flush_pending_blocks(MI_CHECK *param);*/
83
 
static SORT_KEY_BLOCKS  *alloc_key_blocks(MI_CHECK *param, uint blocks,
84
 
                                          uint buffer_length);
85
 
static ha_checksum mi_byte_checksum(const unsigned char *buf, uint length);
 
83
static SORT_KEY_BLOCKS  *alloc_key_blocks(MI_CHECK *param, uint32_t blocks,
 
84
                                          uint32_t buffer_length);
 
85
static ha_checksum mi_byte_checksum(const unsigned char *buf, uint32_t length);
86
86
static void set_data_file_type(SORT_INFO *sort_info, MYISAM_SHARE *share);
87
87
 
88
88
void myisamchk_init(MI_CHECK *param)
120
120
  if (share->state.open_count != (uint) (info->s->global_changed ? 1 : 0))
121
121
  {
122
122
    /* Don't count this as a real warning, as check can correct this ! */
123
 
    uint save=param->warning_printed;
 
123
    uint32_t save=param->warning_printed;
124
124
    mi_check_print_warning(param,
125
125
                           share->state.open_count==1 ? 
126
126
                           "%d client is using or hasn't closed the table properly" : 
135
135
 
136
136
        /* Check delete links */
137
137
 
138
 
int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag)
 
138
int chk_del(MI_CHECK *param, register MI_INFO *info, uint32_t test_flag)
139
139
{
140
140
  register ha_rows i;
141
 
  uint delete_link_length;
 
141
  uint32_t delete_link_length;
142
142
  my_off_t empty, next_link, old_link= 0;
143
143
  char buff[22],buff2[22];
144
144
 
242
242
 
243
243
        /* Check delete links in index file */
244
244
 
245
 
static int check_k_link(MI_CHECK *param, register MI_INFO *info, uint nr)
 
245
static int check_k_link(MI_CHECK *param, register MI_INFO *info, uint32_t nr)
246
246
{
247
247
  my_off_t next_link;
248
 
  uint block_size=(nr+1)*MI_MIN_KEY_BLOCK_LENGTH;
 
248
  uint32_t block_size=(nr+1)*MI_MIN_KEY_BLOCK_LENGTH;
249
249
  ha_rows records;
250
250
  char llbuff[21], llbuff2[21];
251
251
  unsigned char *buff;
395
395
 
396
396
int chk_key(MI_CHECK *param, register MI_INFO *info)
397
397
{
398
 
  uint key,found_keys=0,full_text_keys=0,result=0;
 
398
  uint32_t key,found_keys=0,full_text_keys=0,result=0;
399
399
  ha_rows keys;
400
400
  ha_checksum old_record_checksum,init_checksum;
401
401
  my_off_t all_keydata,all_totaldata,key_totlength,length;
527
527
                   (key_part_map)1, HA_READ_KEY_EXACT))
528
528
      {
529
529
        /* Don't count this as a real warning, as myisamchk can't correct it */
530
 
        uint save=param->warning_printed;
 
530
        uint32_t save=param->warning_printed;
531
531
        mi_check_print_warning(param, "Found row where the auto_increment "
532
532
                               "column has the value 0");
533
533
        param->warning_printed=save;
577
577
 
578
578
static int chk_index_down(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
579
579
                     my_off_t page, unsigned char *buff, ha_rows *keys,
580
 
                     ha_checksum *key_checksum, uint level)
 
580
                     ha_checksum *key_checksum, uint32_t level)
581
581
{
582
582
  char llbuff[22],llbuff2[22];
583
583
 
649
649
void mi_collect_stats_nonulls_first(HA_KEYSEG *keyseg, uint64_t *notnull,
650
650
                                    unsigned char *key)
651
651
{
652
 
  uint first_null, kp;
 
652
  uint32_t first_null, kp;
653
653
  first_null= ha_find_null(keyseg, key) - keyseg;
654
654
  /*
655
655
    All prefix tuples that don't include keypart_{first_null} are not-null
689
689
int mi_collect_stats_nonulls_next(HA_KEYSEG *keyseg, uint64_t *notnull,
690
690
                                  unsigned char *prev_key, unsigned char *last_key)
691
691
{
692
 
  uint diffs[2];
693
 
  uint first_null_seg, kp;
 
692
  uint32_t diffs[2];
 
693
  uint32_t first_null_seg, kp;
694
694
  HA_KEYSEG *seg;
695
695
 
696
696
  /* 
723
723
 
724
724
static int chk_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
725
725
                     my_off_t page, unsigned char *buff, ha_rows *keys,
726
 
                     ha_checksum *key_checksum, uint level)
 
726
                     ha_checksum *key_checksum, uint32_t level)
727
727
{
728
728
  int flag;
729
 
  uint used_length,comp_flag,nod_flag,key_length=0;
 
729
  uint32_t used_length,comp_flag,nod_flag,key_length=0;
730
730
  unsigned char key[HA_MAX_POSSIBLE_KEY_BUFF],*temp_buff,*keypos,*old_keypos,*endpos;
731
731
  my_off_t next_page,record;
732
732
  char llbuff[22];
733
 
  uint diff_pos[2];
 
733
  uint32_t diff_pos[2];
734
734
 
735
735
  if (!(temp_buff=(unsigned char*) my_alloca((uint) keyinfo->block_length)))
736
736
  {
862
862
 
863
863
        /* Calc length of key in normal isam */
864
864
 
865
 
static uint isam_key_length(MI_INFO *info, register MI_KEYDEF *keyinfo)
 
865
static uint32_t isam_key_length(MI_INFO *info, register MI_KEYDEF *keyinfo)
866
866
{
867
 
  uint length;
 
867
  uint32_t length;
868
868
  HA_KEYSEG *keyseg;
869
869
 
870
870
  length= info->s->rec_reflength;
1139
1139
        if (mi_is_key_active(info->s->state.key_map, key))
1140
1140
        {
1141
1141
          {
1142
 
            uint key_length=_mi_make_key(info,key,info->lastkey,record,
 
1142
            uint32_t key_length=_mi_make_key(info,key,info->lastkey,record,
1143
1143
                                         start_recpos);
1144
1144
            if (extend)
1145
1145
            {
1336
1336
{
1337
1337
  MYISAM_SHARE *share= info->s;
1338
1338
  MI_STATE_INFO *state= &share->state;
1339
 
  uint i;
 
1339
  uint32_t i;
1340
1340
  int error;
1341
1341
 
1342
1342
  /*
1672
1672
 
1673
1673
static int writekeys(MI_SORT_PARAM *sort_param)
1674
1674
{
1675
 
  register uint i;
 
1675
  register uint32_t i;
1676
1676
  unsigned char    *key;
1677
1677
  MI_INFO  *info=   sort_param->sort_info->info;
1678
1678
  unsigned char    *buff=   sort_param->record;
1684
1684
    if (mi_is_key_active(info->s->state.key_map, i))
1685
1685
    {
1686
1686
      {
1687
 
        uint key_length=_mi_make_key(info,i,key,buff,filepos);
 
1687
        uint32_t key_length=_mi_make_key(info,i,key,buff,filepos);
1688
1688
        if (_mi_ck_write(info,i,key,key_length))
1689
1689
          goto err;
1690
1690
      }
1701
1701
      if (mi_is_key_active(info->s->state.key_map, i))
1702
1702
      {
1703
1703
        {
1704
 
          uint key_length=_mi_make_key(info,i,key,buff,filepos);
 
1704
          uint32_t key_length=_mi_make_key(info,i,key,buff,filepos);
1705
1705
          if (_mi_ck_delete(info,i,key,key_length))
1706
1706
            break;
1707
1707
        }
1718
1718
        /* Change all key-pointers that points to a records */
1719
1719
 
1720
1720
int movepoint(register MI_INFO *info, unsigned char *record, my_off_t oldpos,
1721
 
              my_off_t newpos, uint prot_key)
 
1721
              my_off_t newpos, uint32_t prot_key)
1722
1722
{
1723
 
  register uint i;
 
1723
  register uint32_t i;
1724
1724
  unsigned char *key;
1725
 
  uint key_length;
 
1725
  uint32_t key_length;
1726
1726
 
1727
1727
  key=info->lastkey+info->s->base.max_key_length;
1728
1728
  for (i=0 ; i < info->s->base.keys; i++)
1732
1732
      key_length=_mi_make_key(info,i,key,record,oldpos);
1733
1733
      if (info->s->keyinfo[i].flag & HA_NOSAME)
1734
1734
      {                                 /* Change pointer direct */
1735
 
        uint nod_flag;
 
1735
        uint32_t nod_flag;
1736
1736
        MI_KEYDEF *keyinfo;
1737
1737
        keyinfo=info->s->keyinfo+i;
1738
1738
        if (_mi_search(info,keyinfo,key,USE_WHOLE_KEY,
1795
1795
 
1796
1796
int mi_sort_index(MI_CHECK *param, register MI_INFO *info, char * name)
1797
1797
{
1798
 
  register uint key;
 
1798
  register uint32_t key;
1799
1799
  register MI_KEYDEF *keyinfo;
1800
1800
  File new_file;
1801
1801
  my_off_t index_pos[HA_MAX_POSSIBLE_KEY];
1802
 
  uint r_locks,w_locks;
 
1802
  uint32_t r_locks,w_locks;
1803
1803
  int old_lock;
1804
1804
  MYISAM_SHARE *share=info->s;
1805
1805
  MI_STATE_INFO old_state;
1893
1893
static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
1894
1894
                          my_off_t pagepos, File new_file)
1895
1895
{
1896
 
  uint length,nod_flag,used_length, key_length;
 
1896
  uint32_t length,nod_flag,used_length, key_length;
1897
1897
  unsigned char *buff,*keypos,*endpos;
1898
1898
  unsigned char key[HA_MAX_POSSIBLE_KEY_BUFF];
1899
1899
  my_off_t new_page_pos,next_page;
1964
1964
 
1965
1965
int change_to_newfile(const char * filename, const char * old_ext,
1966
1966
                      const char * new_ext,
1967
 
                      uint raid_chunks __attribute__((unused)),
 
1967
                      uint32_t raid_chunks __attribute__((unused)),
1968
1968
                      myf MyFlags)
1969
1969
{
1970
1970
  char old_filename[FN_REFLEN],new_filename[FN_REFLEN];
2033
2033
                      const char * name, int rep_quick)
2034
2034
{
2035
2035
  int got_error;
2036
 
  uint i;
 
2036
  uint32_t i;
2037
2037
  ulong length;
2038
2038
  ha_rows start_records;
2039
2039
  my_off_t new_header_length,del;
2415
2415
                        const char * name, int rep_quick)
2416
2416
{
2417
2417
  int got_error;
2418
 
  uint i,key, total_key_length, istep;
 
2418
  uint32_t i,key, total_key_length, istep;
2419
2419
  ulong rec_length;
2420
2420
  ha_rows start_records;
2421
2421
  my_off_t new_header_length,del;
2942
2942
{
2943
2943
  int searching;
2944
2944
  int parallel_flag;
2945
 
  uint found_record,b_type,left_length;
 
2945
  uint32_t found_record,b_type,left_length;
2946
2946
  my_off_t pos;
2947
2947
  unsigned char *to= NULL;
2948
2948
  MI_BLOCK_INFO block_info;
3047
3047
             (block_info.rec_len < (uint) share->base.min_pack_length ||
3048
3048
              block_info.rec_len > (uint) share->base.max_pack_length)))
3049
3049
        {
3050
 
          uint i;
 
3050
          uint32_t i;
3051
3051
          if (param->testflag & T_VERBOSE || searching == 0)
3052
3052
            mi_check_print_info(param,
3053
3053
                                "Wrong bytesec: %3d-%3d-%3d at %10s; Skipped",
3206
3206
          streched over the end of the previous buffer contents.
3207
3207
        */
3208
3208
        {
3209
 
          uint header_len= (uint) (block_info.filepos - pos);
3210
 
          uint prefetch_len= (MI_BLOCK_INFO_HEADER_LENGTH - header_len);
 
3209
          uint32_t header_len= (uint) (block_info.filepos - pos);
 
3210
          uint32_t prefetch_len= (MI_BLOCK_INFO_HEADER_LENGTH - header_len);
3211
3211
 
3212
3212
          if (prefetch_len > block_info.data_len)
3213
3213
            prefetch_len= block_info.data_len;
3400
3400
static int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,
3401
3401
                        const void *b)
3402
3402
{
3403
 
  uint not_used[2];
 
3403
  uint32_t not_used[2];
3404
3404
  return (ha_key_cmp(sort_param->seg, *((unsigned char* const *) a), *((unsigned char* const *) b),
3405
3405
                     USE_WHOLE_KEY, SEARCH_SAME, not_used));
3406
3406
} /* sort_key_cmp */
3408
3408
 
3409
3409
static int sort_key_write(MI_SORT_PARAM *sort_param, const void *a)
3410
3410
{
3411
 
  uint diff_pos[2];
 
3411
  uint32_t diff_pos[2];
3412
3412
  char llbuff[22],llbuff2[22];
3413
3413
  SORT_INFO *sort_info=sort_param->sort_info;
3414
3414
  MI_CHECK *param= sort_info->param;
3476
3476
                           register SORT_KEY_BLOCKS *key_block, unsigned char *key,
3477
3477
                           my_off_t prev_block)
3478
3478
{
3479
 
  uint a_length,t_length,nod_flag;
 
3479
  uint32_t a_length,t_length,nod_flag;
3480
3480
  my_off_t filepos,key_file_length;
3481
3481
  unsigned char *anc_buff,*lastkey;
3482
3482
  MI_KEY_PARAM s_temp;
3556
3556
 
3557
3557
static int sort_delete_record(MI_SORT_PARAM *sort_param)
3558
3558
{
3559
 
  uint i;
 
3559
  uint32_t i;
3560
3560
  int old_file,error;
3561
3561
  unsigned char *key;
3562
3562
  SORT_INFO *sort_info=sort_param->sort_info;
3591
3591
 
3592
3592
    for (i=0 ; i < sort_info->current_key ; i++)
3593
3593
    {
3594
 
      uint key_length=_mi_make_key(info,i,key,sort_param->record,info->lastpos);
 
3594
      uint32_t key_length=_mi_make_key(info,i,key,sort_param->record,info->lastpos);
3595
3595
      if (_mi_ck_delete(info,i,key,key_length))
3596
3596
      {
3597
3597
        mi_check_print_error(param,"Can't delete key %d from record to be removed",i+1);
3612
3612
 
3613
3613
int flush_pending_blocks(MI_SORT_PARAM *sort_param)
3614
3614
{
3615
 
  uint nod_flag,length;
 
3615
  uint32_t nod_flag,length;
3616
3616
  my_off_t filepos,key_file_length;
3617
3617
  SORT_KEY_BLOCKS *key_block;
3618
3618
  SORT_INFO *sort_info= sort_param->sort_info;
3651
3651
 
3652
3652
        /* alloc space and pointers for key_blocks */
3653
3653
 
3654
 
static SORT_KEY_BLOCKS *alloc_key_blocks(MI_CHECK *param, uint blocks,
3655
 
                                         uint buffer_length)
 
3654
static SORT_KEY_BLOCKS *alloc_key_blocks(MI_CHECK *param, uint32_t blocks,
 
3655
                                         uint32_t buffer_length)
3656
3656
{
3657
 
  register uint i;
 
3657
  register uint32_t i;
3658
3658
  SORT_KEY_BLOCKS *block;
3659
3659
 
3660
3660
  if (!(block=(SORT_KEY_BLOCKS*) my_malloc((sizeof(SORT_KEY_BLOCKS)+
3697
3697
  MI_COLUMNDEF *recdef,*rec,*end;
3698
3698
  MI_UNIQUEDEF *uniquedef,*u_ptr,*u_end;
3699
3699
  MI_STATUS_INFO status_info;
3700
 
  uint unpack,key_parts;
 
3700
  uint32_t unpack,key_parts;
3701
3701
  ha_rows max_records;
3702
3702
  uint64_t file_length,tmp_length;
3703
3703
  MI_CREATE_INFO create_info;
3878
3878
 
3879
3879
        /* Update state and myisamchk_time of indexfile */
3880
3880
 
3881
 
int update_state_info(MI_CHECK *param, MI_INFO *info,uint update)
 
3881
int update_state_info(MI_CHECK *param, MI_INFO *info,uint32_t update)
3882
3882
{
3883
3883
  MYISAM_SHARE *share=info->s;
3884
3884
 
3889
3889
  }
3890
3890
  if (update & UPDATE_STAT)
3891
3891
  {
3892
 
    uint i, key_parts= mi_uint2korr(share->state.header.key_parts);
 
3892
    uint32_t i, key_parts= mi_uint2korr(share->state.header.key_parts);
3893
3893
    share->state.rec_per_key_rows=info->state->records;
3894
3894
    share->state.changed&= ~STATE_NOT_ANALYZED;
3895
3895
    if (info->state->records)
3923
3923
  }
3924
3924
  {                                             /* Force update of status */
3925
3925
    int error;
3926
 
    uint r_locks=share->r_locks,w_locks=share->w_locks;
 
3926
    uint32_t r_locks=share->r_locks,w_locks=share->w_locks;
3927
3927
    share->r_locks= share->w_locks= share->tot_locks= 0;
3928
3928
    error=_mi_writeinfo(info,WRITEINFO_NO_UNLOCK);
3929
3929
    share->r_locks=r_locks;
4061
4061
{
4062
4062
  uint64_t count=0,tmp, unique_tuples;
4063
4063
  uint64_t tuples= records;
4064
 
  uint parts;
 
4064
  uint32_t parts;
4065
4065
  for (parts=0 ; parts < keyinfo->keysegs  ; parts++)
4066
4066
  {
4067
4067
    count+=unique[parts];
4098
4098
}
4099
4099
 
4100
4100
 
4101
 
static ha_checksum mi_byte_checksum(const unsigned char *buf, uint length)
 
4101
static ha_checksum mi_byte_checksum(const unsigned char *buf, uint32_t length)
4102
4102
{
4103
4103
  ha_checksum crc;
4104
4104
  const unsigned char *end=buf+length;
4110
4110
 
4111
4111
static bool mi_too_big_key_for_sort(MI_KEYDEF *key, ha_rows rows)
4112
4112
{
4113
 
  uint key_maxlength=key->maxlength;
 
4113
  uint32_t key_maxlength=key->maxlength;
4114
4114
  return (key->flag & (HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY) &&
4115
4115
          ((uint64_t) rows * key_maxlength >
4116
4116
           (uint64_t) myisam_max_temp_length));
4129
4129
{
4130
4130
  MYISAM_SHARE *share=info->s;
4131
4131
  MI_KEYDEF    *key=share->keyinfo;
4132
 
  uint          i;
 
4132
  uint32_t          i;
4133
4133
 
4134
4134
  assert(info->state->records == 0 &&
4135
4135
              (!rows || rows >= MI_MIN_ROWS_TO_DISABLE_INDEXES));
4156
4156
{
4157
4157
  MYISAM_SHARE *share=info->s;
4158
4158
  MI_KEYDEF *key=share->keyinfo;
4159
 
  uint i;
 
4159
  uint32_t i;
4160
4160
 
4161
4161
  /*
4162
4162
    mi_repair_by_sort only works if we have at least one key. If we don't