← Back to branch summary

~eday/drizzle/eday-dev

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_open.cc

  • Committer: Eric Day
  • Date: 2010-01-07 20:02:38 UTC
  • mfrom: (971.3.291 staging)
  • Revision ID: eday@oddments.org-20100107200238-uqw8v6kv9pl7nny5
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_open.cc
20
20
#include <string.h>
21
21
#include <algorithm>
22
22
 
23
 
#include "mystrings/m_ctype.h"
24
 
#include "mystrings/m_string.h"
 
23
#include "drizzled/charset_info.h"
 
24
#include "drizzled/internal/m_string.h"
25
25
#include "drizzled/util/test.h"
 
26
#include "drizzled/global_charset_info.h"
 
27
#include "drizzled/charset.h"
26
28
#include "drizzled/memory/multi_malloc.h"
27
29
 
28
30
 
40
42
#define disk_pos_assert(pos, end_pos) \
41
43
if (pos > end_pos)             \
42
44
{                              \
43
 
  my_errno=HA_ERR_CRASHED;     \
 
45
  errno=HA_ERR_CRASHED;     \
44
46
  goto err;                    \
45
47
}
46
48
 
121
123
    if (my_read(kfile, share->state.header.file_version, head_length,
122
124
                MYF(MY_NABP)))
123
125
    {
124
 
      my_errno= HA_ERR_NOT_A_TABLE;
 
126
      errno= HA_ERR_NOT_A_TABLE;
125
127
      goto err;
126
128
    }
127
129
    if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
128
130
    {
129
 
      my_errno=HA_ERR_NOT_A_TABLE;
 
131
      errno=HA_ERR_NOT_A_TABLE;
130
132
      goto err;
131
133
    }
132
134
    share->options= mi_uint2korr(share->state.header.options);
137
139
          HA_OPTION_TMP_TABLE
138
140
          ))
139
141
    {
140
 
      my_errno=HA_ERR_OLD_FILE;
 
142
      errno=HA_ERR_OLD_FILE;
141
143
      goto err;
142
144
    }
143
145
 
155
157
    base_pos=mi_uint2korr(share->state.header.base_pos);
156
158
    if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
157
159
    {
158
 
      my_errno=ENOMEM;
 
160
      errno=ENOMEM;
159
161
      goto err;
160
162
    }
161
163
    end_pos=disk_cache+info_length;
165
167
    errpos=3;
166
168
    if (my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
167
169
    {
168
 
      my_errno=HA_ERR_CRASHED;
 
170
      errno=HA_ERR_CRASHED;
169
171
      goto err;
170
172
    }
171
173
    len=mi_uint2korr(share->state.header.state_info_length);
183
185
 
184
186
    if (share->state.changed & STATE_CRASHED)
185
187
    {
186
 
      my_errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
 
188
      errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
187
189
                HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
188
190
      goto err;
189
191
    }
191
193
    /* sanity check */
192
194
    if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
193
195
    {
194
 
      my_errno=HA_ERR_CRASHED;
 
196
      errno=HA_ERR_CRASHED;
195
197
      goto err;
196
198
    }
197
199
 
198
200
    if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
199
201
        key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
200
202
    {
201
 
      my_errno=HA_ERR_UNSUPPORTED;
 
203
      errno=HA_ERR_UNSUPPORTED;
202
204
      goto err;
203
205
    }
204
206
 
217
219
#endif
218
220
    if (share->base.raid_type)
219
221
    {
220
 
      my_errno=HA_ERR_UNSUPPORTED;
 
222
      errno=HA_ERR_UNSUPPORTED;
221
223
      goto err;
222
224
    }
223
225
    share->base.max_data_file_length=(my_off_t) max_data_file_length;
279
281
              ! (share->options & (HA_OPTION_COMPRESS_RECORD |
280
282
                                   HA_OPTION_PACK_RECORD)))
281
283
          {
282
 
            my_errno= HA_ERR_CRASHED;
 
284
            errno= HA_ERR_CRASHED;
283
285
            goto err;
284
286
          }
285
287
          if (pos->type == HA_KEYTYPE_TEXT ||
290
292
              pos->charset=default_charset_info;
291
293
            else if (!(pos->charset= get_charset(pos->language)))
292
294
            {
293
 
              my_errno=HA_ERR_UNKNOWN_CHARSET;
 
295
              errno=HA_ERR_UNKNOWN_CHARSET;
294
296
              goto err;
295
297
            }
296
298
          }
322
324
              pos->charset=default_charset_info;
323
325
            else if (!(pos->charset= get_charset(pos->language)))
324
326
            {
325
 
              my_errno=HA_ERR_UNKNOWN_CHARSET;
 
327
              errno=HA_ERR_UNKNOWN_CHARSET;
326
328
              goto err;
327
329
            }
328
330
          }
354
356
    share->rec[i].type=(int) FIELD_LAST;        /* End marker */
355
357
    if (offset > share->base.reclength)
356
358
    {
357
 
      my_errno= HA_ERR_CRASHED;
 
359
      errno= HA_ERR_CRASHED;
358
360
      goto err;
359
361
    }
360
362
 
418
420
    share= old_info->s;
419
421
    if (mode == O_RDWR && share->mode == O_RDONLY)
420
422
    {
421
 
      my_errno=EACCES;                          /* Can't open in write mode */
 
423
      errno=EACCES;                             /* Can't open in write mode */
422
424
      goto err;
423
425
    }
424
426
    if (mi_open_datafile(&info, share, old_info->dfile))
514
516
err:
515
517
  if (disk_cache != NULL)
516
518
    free(disk_cache);
517
 
  save_errno=my_errno ? my_errno : HA_ERR_END_OF_FILE;
 
519
  save_errno=errno ? errno : HA_ERR_END_OF_FILE;
518
520
  if ((save_errno == HA_ERR_CRASHED) ||
519
521
      (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
520
522
      (save_errno == HA_ERR_CRASHED_ON_REPAIR))
541
543
    break;
542
544
  }
543
545
  pthread_mutex_unlock(&THR_LOCK_myisam);
544
 
  my_errno=save_errno;
 
546
  errno=save_errno;
545
547
  return (NULL);
546
548
} /* mi_open */
547
549
 
693
695
   Function to save and store the header in the index file (.MYI)
694
696
*/
695
697
 
696
 
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite)
 
698
uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite)
697
699
{
698
700
  unsigned char  buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
699
701
  unsigned char *ptr=buff;
809
811
}
810
812
 
811
813
 
812
 
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead)
 
814
uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead)
813
815
{
814
816
  unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
815
817
 
830
832
**  store and read of MI_BASE_INFO
831
833
****************************************************************************/
832
834
 
833
 
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base)
 
835
uint32_t mi_base_info_write(int file, MI_BASE_INFO *base)
834
836
{
835
837
  unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
836
838
 
905
907
  mi_keydef
906
908
---------------------------------------------------------------------------*/
907
909
 
908
 
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef)
 
910
uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef)
909
911
{
910
912
  unsigned char buff[MI_KEYDEF_SIZE];
911
913
  unsigned char *ptr=buff;
940
942
**  mi_keyseg
941
943
***************************************************************************/
942
944
 
943
 
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg)
 
945
int mi_keyseg_write(int file, const HA_KEYSEG *keyseg)
944
946
{
945
947
  unsigned char buff[HA_KEYSEG_SIZE];
946
948
  unsigned char *ptr=buff;
990
992
  mi_uniquedef
991
993
---------------------------------------------------------------------------*/
992
994
 
993
 
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *def)
 
995
uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *def)
994
996
{
995
997
  unsigned char buff[MI_UNIQUEDEF_SIZE];
996
998
  unsigned char *ptr=buff;
1014
1016
**  MI_COLUMNDEF
1015
1017
***************************************************************************/
1016
1018
 
1017
 
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo)
 
1019
uint32_t mi_recinfo_write(int file, MI_COLUMNDEF *recinfo)
1018
1020
{
1019
1021
  unsigned char buff[MI_COLUMNDEF_SIZE];
1020
1022
  unsigned char *ptr=buff;
1044
1046
exist a dup()-like call that would give us two different file descriptors.
1045
1047
*************************************************************************/
1046
1048
 
1047
 
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup)
 
1049
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)
1048
1050
{
1049
1051
  (void)file_to_dup; 
1050
1052
  info->dfile=my_open(share->data_file_name, share->mode,