~drizzle-developers/ubuntu/natty/drizzle/natty

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_open.cc

• browse files at revision 0.1.2
• compare with another revision
• download diff
• download tarball
• view history from revision 0.1.2

Show diffs side-by-side

added

removed

plugin/myisam/mi_open.cc

29

29

 

30

30

 

31

31

using namespace std;

 

32

using namespace drizzled;

32

33

 

33

34

static void setup_key_functions(MI_KEYDEF *keyinfo);

34

35

static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef);

87

88

  MI_INFO info,*m_info,*old_info;

88

89

  MYISAM_SHARE share_buff,*share;

89

90

  ulong rec_per_key_part[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG];

90

 

  my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];

 

91

  internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];

91

92

  uint64_t max_key_file_length, max_data_file_length;

92

93

 

93

94

  kfile= -1;

96

97

  head_length=sizeof(share_buff.state.header);

97

98

  memset(&info, 0, sizeof(info));

98

99

 

99

 

  (void)fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);

 

100

  (void)internal::fn_format(org_name,name,"",MI_NAME_IEXT, MY_UNPACK_FILENAME);

100

101

  if (!realpath(org_name,rp_buff))

101

 

    my_load_path(rp_buff,org_name, NULL);

 

102

    internal::my_load_path(rp_buff,org_name, NULL);

102

103

  rp_buff[FN_REFLEN-1]= '\0';

103

104

  strcpy(name_buff,rp_buff);

104

105

  pthread_mutex_lock(&THR_LOCK_myisam);

111

112

    share_buff.state.key_del=key_del;

112

113

    share_buff.key_cache= dflt_key_cache;

113

114

 

114

 

    if ((kfile=my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)

 

115

    if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)

115

116

    {

116

117

      if ((errno != EROFS && errno != EACCES) ||

117

118

          mode != O_RDONLY ||

118

 

          (kfile=my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)

 

119

          (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)

119

120

        goto err;

120

121

    }

121

122

    share->mode=open_mode;

122

123

    errpos=1;

123

 

    if (my_read(kfile, share->state.header.file_version, head_length,

 

124

    if (internal::my_read(kfile, share->state.header.file_version, head_length,

124

125

                MYF(MY_NABP)))

125

126

    {

126

127

      errno= HA_ERR_NOT_A_TABLE;

150

151

    if (!strcmp(name_buff, org_name) || sym_link_size == -1)

151

152

      (void) strcpy(index_name, org_name);

152

153

    *strrchr(org_name, '.')= '\0';

153

 

    (void) fn_format(data_name,org_name,"",MI_NAME_DEXT,

 

154

    (void) internal::fn_format(data_name,org_name,"",MI_NAME_DEXT,

154

155

                     MY_APPEND_EXT|MY_UNPACK_FILENAME|MY_RESOLVE_SYMLINKS);

155

156

 

156

157

    info_length=mi_uint2korr(share->state.header.header_length);

165

166

 

166

167

    lseek(kfile,0,SEEK_SET);

167

168

    errpos=3;

168

 

    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))

 

169

    if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))

169

170

    {

170

171

      errno=HA_ERR_CRASHED;

171

172

      goto err;

222

223

      errno=HA_ERR_UNSUPPORTED;

223

224

      goto err;

224

225

    }

225

 

    share->base.max_data_file_length=(my_off_t) max_data_file_length;

226

 

    share->base.max_key_file_length=(my_off_t) max_key_file_length;

 

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;

227

228

 

228

229

    if (share->options & HA_OPTION_COMPRESS_RECORD)

229

230

      share->base.max_key_length+=2;    /* For safety */

255

256

    memcpy(share->state.rec_per_key_part, rec_per_key_part,

256

257

           sizeof(long)*key_parts);

257

258

    memcpy(share->state.key_root, key_root,

258

 

           sizeof(my_off_t)*keys);

 

259

           sizeof(internal::my_off_t)*keys);

259

260

    memcpy(share->state.key_del, key_del,

260

 

           sizeof(my_off_t) * share->state.header.max_block_size_index);

 

261

           sizeof(internal::my_off_t) * share->state.header.max_block_size_index);

261

262

    strcpy(share->unique_file_name, name_buff);

262

263

    share->unique_name_length= strlen(name_buff);

263

264

    strcpy(share->index_file_name,  index_name);

526

527

    free((unsigned char*) m_info);

527

528

    /* fall through */

528

529

  case 5:

529

 

    my_close(info.dfile,MYF(0));

 

530

    internal::my_close(info.dfile,MYF(0));

530

531

    if (old_info)

531

532

      break;                                    /* Don't remove open table */

532

533

    /* fall through */

536

537

  case 3:

537

538

    /* fall through */

538

539

  case 1:

539

 

    my_close(kfile,MYF(0));

 

540

    internal::my_close(kfile,MYF(0));

540

541

    /* fall through */

541

542

  case 0:

542

543

  default:

588

589

 

589

590

static uint64_t mi_safe_mul(uint64_t a, uint64_t b)

590

591

{

591

 

  uint64_t max_val= ~ (uint64_t) 0;             /* my_off_t is unsigned */

 

592

  uint64_t max_val= ~ (uint64_t) 0;             /* internal::my_off_t is unsigned */

592

593

 

593

594

  if (!a || max_val / a < b)

594

595

    return max_val;

753

754

  if (pWrite & 1)

754

755

    return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,

755

756

                          MYF(MY_NABP | MY_THREADSAFE)) != 0);

756

 

  return(my_write(file, buff, (size_t) (ptr-buff),

 

757

  return(internal::my_write(file, buff, (size_t) (ptr-buff),

757

758

                       MYF(MY_NABP)) != 0);

758

759

}

759

760

 

779

780

  state->state.empty    = mi_sizekorr(ptr);     ptr +=8;

780

781

  state->state.key_empty= mi_sizekorr(ptr);     ptr +=8;

781

782

  state->auto_increment=mi_uint8korr(ptr);      ptr +=8;

782

 

  state->state.checksum=(ha_checksum) mi_uint8korr(ptr);        ptr +=8;

 

783

  state->state.checksum=(internal::ha_checksum) mi_uint8korr(ptr);      ptr +=8;

783

784

  state->process= mi_uint4korr(ptr);            ptr +=4;

784

785

  state->unique = mi_uint4korr(ptr);            ptr +=4;

785

786

  state->status = mi_uint4korr(ptr);            ptr +=4;

820

821

    if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))

821

822

      return 1;

822

823

  }

823

 

  else if (my_read(file, buff, state->state_length,MYF(MY_NABP)))

 

824

  else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))

824

825

    return 1;

825

826

  mi_state_info_read(buff, state);

826

827

 

865

866

  mi_int4store(ptr,UINT32_C(0));                        ptr +=4;

866

867

 

867

868

  memset(ptr, 0, 6);                                    ptr +=6; /* extra */

868

 

  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

 

869

  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

869

870

}

870

871

 

871

872

 

919

920

  mi_int2store(ptr,keydef->keylength);          ptr +=2;

920

921

  mi_int2store(ptr,keydef->minlength);          ptr +=2;

921

922

  mi_int2store(ptr,keydef->maxlength);          ptr +=2;

922

 

  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

 

923

  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

923

924

}

924

925

 

925

926

static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)

961

962

  mi_int4store(ptr, pos);

962

963

  ptr+=4;

963

964

 

964

 

  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

 

965

  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

965

966

}

966

967

 

967

968

 

1001

1002

  *ptr++=  (unsigned char) def->key;

1002

1003

  *ptr++ = (unsigned char) def->null_are_equal;

1003

1004

 

1004

 

  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

 

1005

  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

1005

1006

}

1006

1007

 

1007

1008

static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)

1025

1026

  mi_int2store(ptr,recinfo->length);    ptr +=2;

1026

1027

  *ptr++ = recinfo->null_bit;

1027

1028

  mi_int2store(ptr,recinfo->null_pos);  ptr+= 2;

1028

 

  return my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

 

1029

  return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;

1029

1030

}

1030

1031

 

1031

1032

static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)

1049

1050

int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)

1050

1051

{

1051

1052

  (void)file_to_dup; 

1052

 

  info->dfile=my_open(share->data_file_name, share->mode,

 

1053

  info->dfile=internal::my_open(share->data_file_name, share->mode,

1053

1054

                      MYF(MY_WME));

1054

1055

  return info->dfile >= 0 ? 0 : 1;

1055

1056

}

1057

1058

 

1058

1059

int mi_open_keyfile(MYISAM_SHARE *share)

1059

1060

{

1060

 

  if ((share->kfile=my_open(share->unique_file_name, share->mode,

 

1061

  if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,

1061

1062

                            MYF(MY_WME))) < 0)

1062

1063

    return 1;

1063

1064

  return 0;

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1