← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/archive/ha_archive.cc

  • 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/archive/ha_archive.cc
280
280
*/
281
281
ARCHIVE_SHARE *ha_archive::get_share(const char *table_name, int *rc)
282
282
{
283
 
  uint length;
 
283
  uint32_t length;
284
284
 
285
285
  pthread_mutex_lock(&archive_mutex);
286
286
  length=(uint) strlen(table_name);
464
464
*/
465
465
int ha_archive::open(const char *name,
466
466
                     int mode __attribute__((unused)),
467
 
                     uint open_options)
 
467
                     uint32_t open_options)
468
468
{
469
469
  int rc= 0;
470
470
  share= get_share(name, &rc);
561
561
 
562
562
  stats.auto_increment_value= create_info->auto_increment_value;
563
563
 
564
 
  for (uint key= 0; key < table_arg->sizeKeys(); key++)
 
564
  for (uint32_t key= 0; key < table_arg->sizeKeys(); key++)
565
565
  {
566
566
    KEY *pos= table_arg->key_info+key;
567
567
    KEY_PART_INFO *key_part=     pos->key_part;
695
695
  uint32_t length= (uint32_t)(table->getRecordLength() + table->sizeFields()*2);
696
696
  length+= ARCHIVE_ROW_HEADER_SIZE;
697
697
 
698
 
  uint *ptr, *end;
 
698
  uint32_t *ptr, *end;
699
699
  for (ptr= table->getBlobField(), end=ptr + table->sizeBlobFields();
700
700
       ptr != end ;
701
701
       ptr++)
852
852
}
853
853
 
854
854
/* Initialized at each key walk (called multiple times unlike rnd_init()) */
855
 
int ha_archive::index_init(uint keynr, bool sorted __attribute__((unused)))
 
855
int ha_archive::index_init(uint32_t keynr, bool sorted __attribute__((unused)))
856
856
{
857
857
  active_index= keynr;
858
858
  return(0);
864
864
  the optimizer that we have unique indexes, we scan
865
865
*/
866
866
int ha_archive::index_read(unsigned char *buf, const unsigned char *key,
867
 
                             uint key_len, enum ha_rkey_function find_flag)
 
867
                             uint32_t key_len, enum ha_rkey_function find_flag)
868
868
{
869
869
  int rc;
870
870
  rc= index_read_idx(buf, active_index, key, key_len, find_flag);
872
872
}
873
873
 
874
874
 
875
 
int ha_archive::index_read_idx(unsigned char *buf, uint index, const unsigned char *key,
876
 
                               uint key_len,
 
875
int ha_archive::index_read_idx(unsigned char *buf, uint32_t index, const unsigned char *key,
 
876
                               uint32_t key_len,
877
877
                               enum ha_rkey_function find_flag __attribute__((unused)))
878
878
{
879
879
  int rc;
1258
1258
/*
1259
1259
  Hints for optimizer, see ha_tina for more information
1260
1260
*/
1261
 
int ha_archive::info(uint flag)
 
1261
int ha_archive::info(uint32_t flag)
1262
1262
{
1263
1263
  /* 
1264
1264
    If dirty, we lock, and then reset/flush the data.