← 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-07-13 22:21:51 UTC
  • Revision ID: brian@tangent.org-20080713222151-fv2tcpbsc829j2oc
Ulonglong to uint64_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/mi_check.c
87
87
{
88
88
  bzero((uchar*) param,sizeof(*param));
89
89
  param->opt_follow_links=1;
90
 
  param->keys_in_use= ~(ulonglong) 0;
 
90
  param->keys_in_use= ~(uint64_t) 0;
91
91
  param->search_after_block=HA_OFFSET_ERROR;
92
92
  param->auto_increment_value= 0;
93
93
  param->use_buffers=USE_BUFFER_INIT;
350
350
  }
351
351
  if (!(param->testflag & T_VERY_SILENT) &&
352
352
      ! (info->s->options & HA_OPTION_COMPRESS_RECORD) &&
353
 
      ulonglong2double(info->state->key_file_length) >
354
 
      ulonglong2double(info->s->base.margin_key_file_length)*0.9)
 
353
      uint64_t2double(info->state->key_file_length) >
 
354
      uint64_t2double(info->s->base.margin_key_file_length)*0.9)
355
355
    mi_check_print_warning(param,"Keyfile is almost full, %10s of %10s used",
356
356
                           llstr(info->state->key_file_length,buff),
357
357
                           llstr(info->s->base.max_key_file_length-1,buff));
384
384
  }
385
385
  if (!(param->testflag & T_VERY_SILENT) &&
386
386
      !(info->s->options & HA_OPTION_COMPRESS_RECORD) &&
387
 
      ulonglong2double(info->state->data_file_length) >
388
 
      (ulonglong2double(info->s->base.max_data_file_length)*0.9))
 
387
      uint64_t2double(info->state->data_file_length) >
 
388
      (uint64_t2double(info->s->base.max_data_file_length)*0.9))
389
389
    mi_check_print_warning(param, "Datafile is almost full, %10s of %10s used",
390
390
                           llstr(info->state->data_file_length,buff),
391
391
                           llstr(info->s->base.max_data_file_length-1,buff2));
504
504
    if ((uint) share->base.auto_key -1 == key)
505
505
    {
506
506
      /* Check that auto_increment key is bigger than max key value */
507
 
      ulonglong auto_increment;
 
507
      uint64_t auto_increment;
508
508
      info->lastinx=key;
509
509
      _mi_read_key_record(info, 0L, info->rec_buff);
510
510
      auto_increment= retrieve_auto_increment(info, info->rec_buff);
553
553
      update_key_parts(keyinfo, rec_per_key_part, param->unique_count,
554
554
                       param->stats_method == MI_STATS_METHOD_IGNORE_NULLS?
555
555
                       param->notnull_count: NULL, 
556
 
                       (ulonglong)info->state->records);
 
556
                       (uint64_t)info->state->records);
557
557
  }
558
558
  if (param->testflag & T_INFO)
559
559
  {
568
568
      puts("");
569
569
  }
570
570
  if (param->key_file_blocks != info->state->key_file_length &&
571
 
      param->keys_in_use != ~(ulonglong) 0)
 
571
      param->keys_in_use != ~(uint64_t) 0)
572
572
    mi_check_print_warning(param, "Some data are unreferenced in keyfile");
573
573
  if (found_keys != full_text_keys)
574
574
    param->record_checksum=old_record_checksum-init_checksum;   /* Remove delete links */
650
650
*/
651
651
 
652
652
static
653
 
void mi_collect_stats_nonulls_first(HA_KEYSEG *keyseg, ulonglong *notnull,
 
653
void mi_collect_stats_nonulls_first(HA_KEYSEG *keyseg, uint64_t *notnull,
654
654
                                    uchar *key)
655
655
{
656
656
  uint first_null, kp;
690
690
*/
691
691
 
692
692
static
693
 
int mi_collect_stats_nonulls_next(HA_KEYSEG *keyseg, ulonglong *notnull,
 
693
int mi_collect_stats_nonulls_next(HA_KEYSEG *keyseg, uint64_t *notnull,
694
694
                                  uchar *prev_key, uchar *last_key)
695
695
{
696
696
  uint diffs[2];
860
860
 
861
861
static ha_checksum calc_checksum(ha_rows count)
862
862
{
863
 
  ulonglong sum,a,b;
 
863
  uint64_t sum,a,b;
864
864
  DBUG_ENTER("calc_checksum");
865
865
 
866
866
  sum=0;
1310
1310
      printf("Records:%18s    M.recordlength:%9lu   Packed:%14.0f%%\n",
1311
1311
             llstr(records,llbuff), (long)((used-link_used)/records),
1312
1312
             (info->s->base.blobs ? 0.0 :
1313
 
              (ulonglong2double((ulonglong) info->s->base.reclength*records)-
 
1313
              (uint64_t2double((uint64_t) info->s->base.reclength*records)-
1314
1314
               my_off_t2double(used))/
1315
 
              ulonglong2double((ulonglong) info->s->base.reclength*records)*100.0));
 
1315
              uint64_t2double((uint64_t) info->s->base.reclength*records)*100.0));
1316
1316
      printf("Recordspace used:%9.0f%%   Empty space:%12d%%  Blocks/Record: %6.2f\n",
1317
 
             (ulonglong2double(used-link_used)/ulonglong2double(used-link_used+empty)*100.0),
1318
 
             (!records ? 100 : (int) (ulonglong2double(del_length+empty)/
 
1317
             (uint64_t2double(used-link_used)/uint64_t2double(used-link_used+empty)*100.0),
 
1318
             (!records ? 100 : (int) (uint64_t2double(del_length+empty)/
1319
1319
                                      my_off_t2double(used)*100.0)),
1320
 
             ulonglong2double(splits - del_blocks) / records);
 
1320
             uint64_t2double(splits - del_blocks) / records);
1321
1321
    }
1322
1322
    printf("Record blocks:%12s    Delete blocks:%10s\n",
1323
1323
           llstr(splits-del_blocks,llbuff),llstr(del_blocks,llbuff2));
2137
2137
  ulong   *rec_per_key_part;
2138
2138
  char llbuff[22];
2139
2139
  SORT_INFO sort_info;
2140
 
  ulonglong key_map= 0;
 
2140
  uint64_t key_map= 0;
2141
2141
  DBUG_ENTER("mi_repair_by_sort");
2142
2142
 
2143
2143
  start_records=info->state->records;
2318
2318
      update_key_parts(sort_param.keyinfo, rec_per_key_part, sort_param.unique,
2319
2319
                       param->stats_method == MI_STATS_METHOD_IGNORE_NULLS?
2320
2320
                       sort_param.notnull: NULL,
2321
 
                       (ulonglong) info->state->records);
 
2321
                       (uint64_t) info->state->records);
2322
2322
    /* Enable this index in the permanent (not the copied) key_map. */
2323
2323
    mi_set_key_active(share->state.key_map, sort_param.key);
2324
2324
    DBUG_PRINT("repair", ("set enabled index #: %u", sort_param.key));
2520
2520
  IO_CACHE new_data_cache; /* For non-quick repair. */
2521
2521
  IO_CACHE_SHARE io_share;
2522
2522
  SORT_INFO sort_info;
2523
 
  ulonglong key_map= 0;
 
2523
  uint64_t key_map= 0;
2524
2524
  pthread_attr_t thr_attr;
2525
2525
  ulong max_pack_reclength;
2526
2526
  DBUG_ENTER("mi_repair_parallel");
3894
3894
  MI_STATUS_INFO status_info;
3895
3895
  uint unpack,key_parts;
3896
3896
  ha_rows max_records;
3897
 
  ulonglong file_length,tmp_length;
 
3897
  uint64_t file_length,tmp_length;
3898
3898
  MI_CREATE_INFO create_info;
3899
3899
  DBUG_ENTER("recreate_table");
3900
3900
 
3982
3982
    (param->testflag & T_UNPACK);
3983
3983
  share.options&= ~HA_OPTION_TEMP_COMPRESS_RECORD;
3984
3984
 
3985
 
  file_length=(ulonglong) my_seek(info.dfile,0L,MY_SEEK_END,MYF(0));
 
3985
  file_length=(uint64_t) my_seek(info.dfile,0L,MY_SEEK_END,MYF(0));
3986
3986
  tmp_length= file_length+file_length/10;
3987
3987
  set_if_bigger(file_length,param->max_data_file_length);
3988
3988
  set_if_bigger(file_length,tmp_length);
3989
 
  set_if_bigger(file_length,(ulonglong) share.base.max_data_file_length);
 
3989
  set_if_bigger(file_length,(uint64_t) share.base.max_data_file_length);
3990
3990
 
3991
3991
  VOID(mi_close(*org_info));
3992
3992
  bzero((char*) &create_info,sizeof(create_info));
4191
4191
  }
4192
4192
  else
4193
4193
  {
4194
 
    ulonglong auto_increment= retrieve_auto_increment(info, record);
 
4194
    uint64_t auto_increment= retrieve_auto_increment(info, record);
4195
4195
    set_if_bigger(info->s->state.auto_increment,auto_increment);
4196
4196
    if (!repair_only)
4197
4197
      set_if_bigger(info->s->state.auto_increment, param->auto_increment_value);
4255
4255
*/
4256
4256
 
4257
4257
void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,
4258
 
                      ulonglong *unique, ulonglong *notnull,
4259
 
                      ulonglong records)
 
4258
                      uint64_t *unique, uint64_t *notnull,
 
4259
                      uint64_t records)
4260
4260
{
4261
 
  ulonglong count=0,tmp, unique_tuples;
4262
 
  ulonglong tuples= records;
 
4261
  uint64_t count=0,tmp, unique_tuples;
 
4262
  uint64_t tuples= records;
4263
4263
  uint parts;
4264
4264
  for (parts=0 ; parts < keyinfo->keysegs  ; parts++)
4265
4265
  {
4288
4288
      let's ensure it is not
4289
4289
    */
4290
4290
    set_if_bigger(tmp,1);
4291
 
    if (tmp >= (ulonglong) ~(ulong) 0)
4292
 
      tmp=(ulonglong) ~(ulong) 0;
 
4291
    if (tmp >= (uint64_t) ~(ulong) 0)
 
4292
      tmp=(uint64_t) ~(ulong) 0;
4293
4293
 
4294
4294
    *rec_per_key_part=(ulong) tmp;
4295
4295
    rec_per_key_part++;
4311
4311
{
4312
4312
  uint key_maxlength=key->maxlength;
4313
4313
  return (key->flag & (HA_BINARY_PACK_KEY | HA_VAR_LENGTH_KEY | HA_FULLTEXT) &&
4314
 
          ((ulonglong) rows * key_maxlength >
4315
 
           (ulonglong) myisam_max_temp_length));
 
4314
          ((uint64_t) rows * key_maxlength >
 
4315
           (uint64_t) myisam_max_temp_length));
4316
4316
}
4317
4317
 
4318
4318
/*
4351
4351
*/
4352
4352
 
4353
4353
my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows,
4354
 
                            ulonglong key_map, my_bool force)
 
4354
                            uint64_t key_map, my_bool force)
4355
4355
{
4356
4356
  MYISAM_SHARE *share=info->s;
4357
4357
  MI_KEYDEF *key=share->keyinfo;