← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/myisam.h

  • Committer: Mats Kindahl
  • Date: 2008-08-07 06:24:22 UTC
  • mfrom: (265 drizzle)
  • mto: (264.1.19 codestyle)
  • mto: This revision was merged to the branch mainline in revision 266.
  • Revision ID: mats@mysql.com-20080807062422-20kyv6ssp4grfm0s
Manual merge of lp:drizzle into ~mkindahl/remove-mem-casts.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/myisam.h
21
21
extern "C" {
22
22
#endif
23
23
 
 
24
#ifndef _my_base_h
24
25
#include <drizzled/base.h>
 
26
#endif
25
27
#ifndef _m_ctype_h
26
 
#include <mystrings/m_ctype.h>
 
28
#include <m_ctype.h>
27
29
#endif
28
30
#ifndef _keycache_h
29
31
#include "keycache.h"
30
32
#endif
31
33
#include <mysys/my_handler.h>
32
 
#include <mysys/iocache.h>
33
34
#include <drizzled/plugin.h>
34
35
 
35
36
/*
70
71
  This means that clearing of high keys is ignored, setting one high key
71
72
  sets all high keys.
72
73
*/
73
 
#define MI_KEYMAP_BITS      (64)
74
 
#define MI_KEYMAP_HIGH_MASK (1UL << (MI_KEYMAP_BITS - 1))
 
74
#define MI_KEYMAP_BITS      (8 * SIZEOF_LONG_LONG)
 
75
#define MI_KEYMAP_HIGH_MASK (1ULL << (MI_KEYMAP_BITS - 1))
75
76
#define mi_get_mask_all_keys_active(_keys_) \
76
77
                            (((_keys_) < MI_KEYMAP_BITS) ? \
77
 
                             ((1UL << (_keys_)) - 1UL) : \
78
 
                             (~ 0UL))
 
78
                             ((1ULL << (_keys_)) - 1ULL) : \
 
79
                             (~ 0ULL))
79
80
 
80
81
#if MI_MAX_KEY > MI_KEYMAP_BITS
81
82
 
82
83
#define mi_is_key_active(_keymap_,_keyno_) \
83
84
                            (((_keyno_) < MI_KEYMAP_BITS) ? \
84
 
                             test((_keymap_) & (1UL << (_keyno_))) : \
 
85
                             test((_keymap_) & (1ULL << (_keyno_))) : \
85
86
                             test((_keymap_) & MI_KEYMAP_HIGH_MASK))
86
87
#define mi_set_key_active(_keymap_,_keyno_) \
87
88
                            (_keymap_)|= (((_keyno_) < MI_KEYMAP_BITS) ? \
88
 
                                          (1UL << (_keyno_)) : \
 
89
                                          (1ULL << (_keyno_)) : \
89
90
                                          MI_KEYMAP_HIGH_MASK)
90
91
#define mi_clear_key_active(_keymap_,_keyno_) \
91
92
                            (_keymap_)&= (((_keyno_) < MI_KEYMAP_BITS) ? \
92
 
                                          (~ (1UL << (_keyno_))) : \
93
 
                                          (~ (0UL)) /*ignore*/ )
 
93
                                          (~ (1ULL << (_keyno_))) : \
 
94
                                          (~ (0ULL)) /*ignore*/ )
94
95
 
95
96
#else
96
97
 
97
98
#define mi_is_key_active(_keymap_,_keyno_) \
98
 
                            test((_keymap_) & (1UL << (_keyno_)))
 
99
                            test((_keymap_) & (1ULL << (_keyno_)))
99
100
#define mi_set_key_active(_keymap_,_keyno_) \
100
 
                            (_keymap_)|= (1UL << (_keyno_))
 
101
                            (_keymap_)|= (1ULL << (_keyno_))
101
102
#define mi_clear_key_active(_keymap_,_keyno_) \
102
 
                            (_keymap_)&= (~ (1UL << (_keyno_)))
 
103
                            (_keymap_)&= (~ (1ULL << (_keyno_)))
103
104
 
104
105
#endif
105
106
 
139
140
  uint64_t auto_increment;
140
141
  uint64_t key_map;                     /* Which keys are used */
141
142
  char  *data_file_name, *index_file_name;
142
 
  uint32_t  keys;                               /* Number of keys in use */
 
143
  uint  keys;                           /* Number of keys in use */
143
144
  uint  options;                        /* HA_OPTION_... used */
144
145
  int   errkey,                         /* With key was dupplicated on err */
145
146
        sortkey;                        /* clustered by this key */
147
148
  time_t create_time;                   /* When table was created */
148
149
  time_t check_time;
149
150
  time_t update_time;
150
 
  uint32_t  reflength;
 
151
  uint  reflength;
151
152
  ulong record_offset;
152
153
  ulong *rec_per_key;                   /* for sql optimizing */
153
154
} MI_ISAMINFO;
161
162
  uint64_t auto_increment;
162
163
  uint64_t data_file_length;
163
164
  uint64_t key_file_length;
164
 
  uint32_t old_options;
 
165
  uint old_options;
165
166
  uint8_t language;
166
 
  bool with_auto_increment;
 
167
  my_bool with_auto_increment;
167
168
} MI_CREATE_INFO;
168
169
 
169
170
struct st_myisam_info;                  /* For referense */
189
190
  HA_KEYSEG *seg,*end;
190
191
 
191
192
  int (*bin_search)(struct st_myisam_info *info,struct st_mi_keydef *keyinfo,
192
 
                    unsigned char *page,unsigned char *key,
193
 
                    uint32_t key_len,uint32_t comp_flag,unsigned char * *ret_pos,
194
 
                    unsigned char *buff, bool *was_last_key);
195
 
  uint32_t (*get_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char * *page,
196
 
                  unsigned char *key);
197
 
  int (*pack_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char *next_key,
198
 
                  unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
 
193
                    uchar *page,uchar *key,
 
194
                    uint key_len,uint comp_flag,uchar * *ret_pos,
 
195
                    uchar *buff, my_bool *was_last_key);
 
196
  uint (*get_key)(struct st_mi_keydef *keyinfo,uint nod_flag,uchar * *page,
 
197
                  uchar *key);
 
198
  int (*pack_key)(struct st_mi_keydef *keyinfo,uint nod_flag,uchar *next_key,
 
199
                  uchar *org_key, uchar *prev_key, uchar *key,
199
200
                  struct st_mi_s_param *s_temp);
200
 
  void (*store_key)(struct st_mi_keydef *keyinfo, unsigned char *key_pos,
 
201
  void (*store_key)(struct st_mi_keydef *keyinfo, uchar *key_pos,
201
202
                    struct st_mi_s_param *s_temp);
202
 
  int (*ck_insert)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
203
 
  int (*ck_delete)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
 
203
  int (*ck_insert)(struct st_myisam_info *inf, uint k_nr, uchar *k, uint klen);
 
204
  int (*ck_delete)(struct st_myisam_info *inf, uint k_nr, uchar *k, uint klen);
204
205
} MI_KEYDEF;
205
206
 
206
207
 
209
210
typedef struct st_unique_def            /* Segment definition of unique */
210
211
{
211
212
  uint16_t keysegs;                     /* Number of key-segment */
212
 
  unsigned char key;                            /* Mapped to which key */
 
213
  uchar key;                            /* Mapped to which key */
213
214
  uint8_t null_are_equal;
214
215
  HA_KEYSEG *seg,*end;
215
216
} MI_UNIQUEDEF;
218
219
{
219
220
  uint16_t *table;
220
221
  uint   quick_table_bits;
221
 
  unsigned char  *intervalls;
 
222
  uchar  *intervalls;
222
223
} MI_DECODE_TREE;
223
224
 
224
225
 
240
241
 
241
242
#ifndef NOT_PACKED_DATABASES
242
243
  void (*unpack)(struct st_columndef *rec,struct st_mi_bit_buff *buff,
243
 
                 unsigned char *start,unsigned char *end);
 
244
                 uchar *start,uchar *end);
244
245
  enum en_fieldtype base_type;
245
 
  uint32_t space_length_bits,pack_type;
 
246
  uint space_length_bits,pack_type;
246
247
  MI_DECODE_TREE *huff_tree;
247
248
#endif
248
249
} MI_COLUMNDEF;
249
250
 
250
251
 
251
252
extern char * myisam_log_filename;              /* Name of logfile */
252
 
extern uint32_t myisam_block_size;
253
 
extern uint32_t myisam_concurrent_insert;
 
253
extern ulong myisam_block_size;
 
254
extern ulong myisam_concurrent_insert;
254
255
extern bool myisam_flush,myisam_delay_key_write,myisam_single_user;
255
256
extern my_off_t myisam_max_temp_length;
256
 
extern uint32_t myisam_bulk_insert_tree_size, myisam_data_pointer_size;
 
257
extern ulong myisam_bulk_insert_tree_size, myisam_data_pointer_size;
257
258
 
258
259
        /* Prototypes for myisam-functions */
259
260
 
260
261
extern int mi_close(struct st_myisam_info *file);
261
 
extern int mi_delete(struct st_myisam_info *file,const unsigned char *buff);
 
262
extern int mi_delete(struct st_myisam_info *file,const uchar *buff);
262
263
extern struct st_myisam_info *mi_open(const char *name,int mode,
263
 
                                      uint32_t wait_if_locked);
 
264
                                      uint wait_if_locked);
264
265
extern int mi_panic(enum ha_panic_function function);
265
 
extern int mi_rfirst(struct st_myisam_info *file,unsigned char *buf,int inx);
266
 
extern int mi_rkey(MI_INFO *info, unsigned char *buf, int inx, const unsigned char *key,
 
266
extern int mi_rfirst(struct st_myisam_info *file,uchar *buf,int inx);
 
267
extern int mi_rkey(MI_INFO *info, uchar *buf, int inx, const uchar *key,
267
268
                   key_part_map keypart_map, enum ha_rkey_function search_flag);
268
 
extern int mi_rlast(struct st_myisam_info *file,unsigned char *buf,int inx);
269
 
extern int mi_rnext(struct st_myisam_info *file,unsigned char *buf,int inx);
270
 
extern int mi_rnext_same(struct st_myisam_info *info, unsigned char *buf);
271
 
extern int mi_rprev(struct st_myisam_info *file,unsigned char *buf,int inx);
272
 
extern int mi_rrnd(struct st_myisam_info *file,unsigned char *buf, my_off_t pos);
 
269
extern int mi_rlast(struct st_myisam_info *file,uchar *buf,int inx);
 
270
extern int mi_rnext(struct st_myisam_info *file,uchar *buf,int inx);
 
271
extern int mi_rnext_same(struct st_myisam_info *info, uchar *buf);
 
272
extern int mi_rprev(struct st_myisam_info *file,uchar *buf,int inx);
 
273
extern int mi_rrnd(struct st_myisam_info *file,uchar *buf, my_off_t pos);
273
274
extern int mi_scan_init(struct st_myisam_info *file);
274
 
extern int mi_scan(struct st_myisam_info *file,unsigned char *buf);
275
 
extern int mi_rsame(struct st_myisam_info *file,unsigned char *record,int inx);
276
 
extern int mi_rsame_with_pos(struct st_myisam_info *file,unsigned char *record,
 
275
extern int mi_scan(struct st_myisam_info *file,uchar *buf);
 
276
extern int mi_rsame(struct st_myisam_info *file,uchar *record,int inx);
 
277
extern int mi_rsame_with_pos(struct st_myisam_info *file,uchar *record,
277
278
                             int inx, my_off_t pos);
278
 
extern int mi_update(struct st_myisam_info *file,const unsigned char *old,
279
 
                     unsigned char *new_record);
280
 
extern int mi_write(struct st_myisam_info *file,unsigned char *buff);
 
279
extern int mi_update(struct st_myisam_info *file,const uchar *old,
 
280
                     uchar *new_record);
 
281
extern int mi_write(struct st_myisam_info *file,uchar *buff);
281
282
extern my_off_t mi_position(struct st_myisam_info *file);
282
 
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint32_t flag);
 
283
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint flag);
283
284
extern int mi_lock_database(struct st_myisam_info *file,int lock_type);
284
 
extern int mi_create(const char *name,uint32_t keys,MI_KEYDEF *keydef,
285
 
                     uint32_t columns, MI_COLUMNDEF *columndef,
286
 
                     uint32_t uniques, MI_UNIQUEDEF *uniquedef,
287
 
                     MI_CREATE_INFO *create_info, uint32_t flags);
 
285
extern int mi_create(const char *name,uint keys,MI_KEYDEF *keydef,
 
286
                     uint columns, MI_COLUMNDEF *columndef,
 
287
                     uint uniques, MI_UNIQUEDEF *uniquedef,
 
288
                     MI_CREATE_INFO *create_info, uint flags);
288
289
extern int mi_delete_table(const char *name);
289
290
extern int mi_rename(const char *from, const char *to);
290
291
extern int mi_extra(struct st_myisam_info *file,
296
297
extern int mi_log(int activate_log);
297
298
extern int mi_is_changed(struct st_myisam_info *info);
298
299
extern int mi_delete_all_rows(struct st_myisam_info *info);
299
 
extern ulong _mi_calc_blob_length(uint32_t length , const unsigned char *pos);
300
 
extern uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def);
 
300
extern ulong _mi_calc_blob_length(uint length , const uchar *pos);
 
301
extern uint mi_get_pointer_length(uint64_t file_length, uint def);
301
302
 
302
303
/* this is used to pass to mysql_myisamchk_table */
303
304
 
365
366
 
366
367
typedef struct st_sort_key_blocks               /* Used when sorting */
367
368
{
368
 
  unsigned char *buff,*end_pos;
369
 
  unsigned char lastkey[MI_MAX_POSSIBLE_KEY_BUFF];
370
 
  uint32_t last_length;
 
369
  uchar *buff,*end_pos;
 
370
  uchar lastkey[MI_MAX_POSSIBLE_KEY_BUFF];
 
371
  uint last_length;
371
372
  int inited;
372
373
} SORT_KEY_BLOCKS;
373
374
 
401
402
  ha_checksum record_checksum,glob_crc;
402
403
  ulong use_buffers,read_buffer_length,write_buffer_length,
403
404
        sort_buffer_length,sort_key_blocks;
404
 
  uint32_t out_flag,warning_printed,error_printed,verbose;
405
 
  uint32_t opt_sort_key,total_files,max_level;
406
 
  uint32_t testflag, key_cache_block_size;
 
405
  uint out_flag,warning_printed,error_printed,verbose;
 
406
  uint opt_sort_key,total_files,max_level;
 
407
  uint testflag, key_cache_block_size;
407
408
  uint8_t language;
408
 
  bool using_global_keycache, opt_lock_memory, opt_follow_links;
409
 
  bool retry_repair, force_sort;
 
409
  my_bool using_global_keycache, opt_lock_memory, opt_follow_links;
 
410
  my_bool retry_repair, force_sort;
410
411
  char temp_filename[FN_REFLEN],*isam_file_name;
411
412
  MY_TMPDIR *tmpdir;
412
413
  int tmpfile_createflag;
432
433
{
433
434
  my_off_t filelength,dupp,buff_length;
434
435
  ha_rows max_records;
435
 
  uint32_t current_key, total_keys;
 
436
  uint current_key, total_keys;
436
437
  myf myf_rw;
437
438
  enum data_file_type new_data_file_type;
438
439
  MI_INFO *info;
439
440
  MI_CHECK *param;
440
 
  unsigned char *buff;
 
441
  uchar *buff;
441
442
  SORT_KEY_BLOCKS *key_block,*key_block_end;
442
443
  /* sync things */
443
 
  uint32_t got_error, threads_running;
 
444
  uint got_error, threads_running;
444
445
  pthread_mutex_t mutex;
445
446
  pthread_cond_t  cond;
446
447
} SORT_INFO;
448
449
/* functions in mi_check */
449
450
void myisamchk_init(MI_CHECK *param);
450
451
int chk_status(MI_CHECK *param, MI_INFO *info);
451
 
int chk_del(MI_CHECK *param, register MI_INFO *info, uint32_t test_flag);
 
452
int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag);
452
453
int chk_size(MI_CHECK *param, MI_INFO *info);
453
454
int chk_key(MI_CHECK *param, MI_INFO *info);
454
455
int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend);
460
461
int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info,
461
462
                      const char * name, int rep_quick);
462
463
int change_to_newfile(const char * filename, const char * old_ext,
463
 
                      const char * new_ext, uint32_t raid_chunks,
 
464
                      const char * new_ext, uint raid_chunks,
464
465
                      myf myflags);
465
466
void lock_memory(MI_CHECK *param);
466
467
void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,
467
 
                               bool repair);
468
 
int update_state_info(MI_CHECK *param, MI_INFO *info,uint32_t update);
 
468
                               my_bool repair);
 
469
int update_state_info(MI_CHECK *param, MI_INFO *info,uint update);
469
470
void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,
470
471
                      uint64_t *unique, uint64_t *notnull, 
471
472
                      uint64_t records);
472
473
int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
473
474
             my_off_t length, const char *type);
474
 
int movepoint(MI_INFO *info,unsigned char *record,my_off_t oldpos,
475
 
              my_off_t newpos, uint32_t prot_key);
476
 
int write_data_suffix(SORT_INFO *sort_info, bool fix_datafile);
 
475
int movepoint(MI_INFO *info,uchar *record,my_off_t oldpos,
 
476
              my_off_t newpos, uint prot_key);
 
477
int write_data_suffix(SORT_INFO *sort_info, my_bool fix_datafile);
477
478
int test_if_almost_full(MI_INFO *info);
478
479
int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename);
479
 
bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, uint64_t key_map,
480
 
                            bool force);
 
480
my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, uint64_t key_map,
 
481
                            my_bool force);
481
482
 
482
 
int mi_init_bulk_insert(MI_INFO *info, uint32_t cache_size, ha_rows rows);
483
 
void mi_flush_bulk_insert(MI_INFO *info, uint32_t inx);
 
483
int mi_init_bulk_insert(MI_INFO *info, ulong cache_size, ha_rows rows);
 
484
void mi_flush_bulk_insert(MI_INFO *info, uint inx);
484
485
void mi_end_bulk_insert(MI_INFO *info);
485
486
int mi_assign_to_key_cache(MI_INFO *info, uint64_t key_map, 
486
487
                           KEY_CACHE *key_cache);
487
488
void mi_change_key_cache(KEY_CACHE *old_key_cache,
488
489
                         KEY_CACHE *new_key_cache);
489
 
int mi_preload(MI_INFO *info, uint64_t key_map, bool ignore_leaves);
 
490
int mi_preload(MI_INFO *info, uint64_t key_map, my_bool ignore_leaves);
490
491
 
491
492
#ifdef  __cplusplus
492
493
}