← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/myisam.h

Merge Monty.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/myisam.h
15
15
 
16
16
/* This file should be included when using myisam_funktions */
17
17
 
18
 
#ifndef _myisam_h
19
 
#define _myisam_h
 
18
#ifndef PLUGIN_MYISAM_MYISAM_H
 
19
#define PLUGIN_MYISAM_MYISAM_H
 
20
 
 
21
#include <drizzled/key_map.h>
 
22
 
20
23
#ifdef  __cplusplus
21
24
extern "C" {
22
25
#endif
23
26
 
24
 
#ifndef _my_base_h
25
 
#include <my_base.h>
26
 
#endif
 
27
#include <drizzled/base.h>
27
28
#ifndef _m_ctype_h
28
 
#include <m_ctype.h>
 
29
#include "drizzled/charset_info.h"
29
30
#endif
30
31
#ifndef _keycache_h
31
32
#include "keycache.h"
32
33
#endif
33
 
#include "my_handler.h"
34
 
#include <drizzle/plugin.h>
 
34
#include <plugin/myisam/my_handler.h>
 
35
#include "drizzled/internal/iocache.h"
35
36
 
36
37
/*
37
38
  Limit max keys according to HA_MAX_POSSIBLE_KEY
71
72
  This means that clearing of high keys is ignored, setting one high key
72
73
  sets all high keys.
73
74
*/
74
 
#define MI_KEYMAP_BITS      (8 * SIZEOF_LONG_LONG)
75
 
#define MI_KEYMAP_HIGH_MASK (1ULL << (MI_KEYMAP_BITS - 1))
 
75
#define MI_KEYMAP_BITS      (64)
 
76
#define MI_KEYMAP_HIGH_MASK (1UL << (MI_KEYMAP_BITS - 1))
76
77
#define mi_get_mask_all_keys_active(_keys_) \
77
78
                            (((_keys_) < MI_KEYMAP_BITS) ? \
78
 
                             ((1ULL << (_keys_)) - 1ULL) : \
79
 
                             (~ 0ULL))
 
79
                             ((1UL << (_keys_)) - 1UL) : \
 
80
                             (~ 0UL))
80
81
 
81
82
#if MI_MAX_KEY > MI_KEYMAP_BITS
82
83
 
83
84
#define mi_is_key_active(_keymap_,_keyno_) \
84
85
                            (((_keyno_) < MI_KEYMAP_BITS) ? \
85
 
                             test((_keymap_) & (1ULL << (_keyno_))) : \
 
86
                             test((_keymap_) & (1UL << (_keyno_))) : \
86
87
                             test((_keymap_) & MI_KEYMAP_HIGH_MASK))
87
88
#define mi_set_key_active(_keymap_,_keyno_) \
88
89
                            (_keymap_)|= (((_keyno_) < MI_KEYMAP_BITS) ? \
89
 
                                          (1ULL << (_keyno_)) : \
 
90
                                          (1UL << (_keyno_)) : \
90
91
                                          MI_KEYMAP_HIGH_MASK)
91
92
#define mi_clear_key_active(_keymap_,_keyno_) \
92
93
                            (_keymap_)&= (((_keyno_) < MI_KEYMAP_BITS) ? \
93
 
                                          (~ (1ULL << (_keyno_))) : \
94
 
                                          (~ (0ULL)) /*ignore*/ )
 
94
                                          (~ (1UL << (_keyno_))) : \
 
95
                                          (~ (0UL)) /*ignore*/ )
95
96
 
96
97
#else
97
98
 
98
99
#define mi_is_key_active(_keymap_,_keyno_) \
99
 
                            test((_keymap_) & (1ULL << (_keyno_)))
 
100
                            test((_keymap_) & (1UL << (_keyno_)))
100
101
#define mi_set_key_active(_keymap_,_keyno_) \
101
 
                            (_keymap_)|= (1ULL << (_keyno_))
 
102
                            (_keymap_)|= (1UL << (_keyno_))
102
103
#define mi_clear_key_active(_keymap_,_keyno_) \
103
 
                            (_keymap_)&= (~ (1ULL << (_keyno_)))
 
104
                            (_keymap_)&= (~ (1UL << (_keyno_)))
104
105
 
105
106
#endif
106
107
 
140
141
  uint64_t auto_increment;
141
142
  uint64_t key_map;                     /* Which keys are used */
142
143
  char  *data_file_name, *index_file_name;
143
 
  uint  keys;                           /* Number of keys in use */
 
144
  uint32_t  keys;                               /* Number of keys in use */
144
145
  uint  options;                        /* HA_OPTION_... used */
145
146
  int   errkey,                         /* With key was dupplicated on err */
146
147
        sortkey;                        /* clustered by this key */
147
 
  File  filenr;                         /* (uniq) filenr for datafile */
 
148
  int   filenr;                         /* (uniq) filenr for datafile */
148
149
  time_t create_time;                   /* When table was created */
149
150
  time_t check_time;
150
151
  time_t update_time;
151
 
  uint  reflength;
 
152
  uint32_t  reflength;
152
153
  ulong record_offset;
153
154
  ulong *rec_per_key;                   /* for sql optimizing */
154
155
} MI_ISAMINFO;
162
163
  uint64_t auto_increment;
163
164
  uint64_t data_file_length;
164
165
  uint64_t key_file_length;
165
 
  uint old_options;
 
166
  uint32_t old_options;
166
167
  uint8_t language;
167
 
  my_bool with_auto_increment;
 
168
  bool with_auto_increment;
168
169
} MI_CREATE_INFO;
169
170
 
170
171
struct st_myisam_info;                  /* For referense */
190
191
  HA_KEYSEG *seg,*end;
191
192
 
192
193
  int (*bin_search)(struct st_myisam_info *info,struct st_mi_keydef *keyinfo,
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,
 
194
                    unsigned char *page,unsigned char *key,
 
195
                    uint32_t key_len,uint32_t comp_flag,unsigned char * *ret_pos,
 
196
                    unsigned char *buff, bool *was_last_key);
 
197
  uint32_t (*get_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char * *page,
 
198
                  unsigned char *key);
 
199
  int (*pack_key)(struct st_mi_keydef *keyinfo,uint32_t nod_flag,unsigned char *next_key,
 
200
                  unsigned char *org_key, unsigned char *prev_key, unsigned char *key,
200
201
                  struct st_mi_s_param *s_temp);
201
 
  void (*store_key)(struct st_mi_keydef *keyinfo, uchar *key_pos,
 
202
  void (*store_key)(struct st_mi_keydef *keyinfo, unsigned char *key_pos,
202
203
                    struct st_mi_s_param *s_temp);
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
  int (*ck_insert)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
 
205
  int (*ck_delete)(struct st_myisam_info *inf, uint32_t k_nr, unsigned char *k, uint32_t klen);
205
206
} MI_KEYDEF;
206
207
 
207
208
 
210
211
typedef struct st_unique_def            /* Segment definition of unique */
211
212
{
212
213
  uint16_t keysegs;                     /* Number of key-segment */
213
 
  uchar key;                            /* Mapped to which key */
 
214
  unsigned char key;                            /* Mapped to which key */
214
215
  uint8_t null_are_equal;
215
216
  HA_KEYSEG *seg,*end;
216
217
} MI_UNIQUEDEF;
219
220
{
220
221
  uint16_t *table;
221
222
  uint   quick_table_bits;
222
 
  uchar  *intervalls;
 
223
  unsigned char  *intervalls;
223
224
} MI_DECODE_TREE;
224
225
 
225
226
 
241
242
 
242
243
#ifndef NOT_PACKED_DATABASES
243
244
  void (*unpack)(struct st_columndef *rec,struct st_mi_bit_buff *buff,
244
 
                 uchar *start,uchar *end);
 
245
                 unsigned char *start,unsigned char *end);
245
246
  enum en_fieldtype base_type;
246
 
  uint space_length_bits,pack_type;
 
247
  uint32_t space_length_bits,pack_type;
247
248
  MI_DECODE_TREE *huff_tree;
248
249
#endif
249
250
} MI_COLUMNDEF;
250
251
 
251
252
 
252
253
extern char * myisam_log_filename;              /* Name of logfile */
253
 
extern ulong myisam_block_size;
254
 
extern ulong myisam_concurrent_insert;
255
 
extern bool myisam_flush,myisam_delay_key_write,myisam_single_user;
256
 
extern my_off_t myisam_max_temp_length;
257
 
extern ulong myisam_bulk_insert_tree_size, myisam_data_pointer_size;
 
254
extern uint32_t myisam_block_size;
 
255
extern uint32_t myisam_concurrent_insert;
 
256
extern uint32_t myisam_bulk_insert_tree_size; 
 
257
extern uint32_t data_pointer_size;
258
258
 
259
259
        /* Prototypes for myisam-functions */
260
260
 
261
261
extern int mi_close(struct st_myisam_info *file);
262
 
extern int mi_delete(struct st_myisam_info *file,const uchar *buff);
 
262
extern int mi_delete(struct st_myisam_info *file,const unsigned char *buff);
263
263
extern struct st_myisam_info *mi_open(const char *name,int mode,
264
 
                                      uint wait_if_locked);
 
264
                                      uint32_t wait_if_locked);
265
265
extern int mi_panic(enum ha_panic_function function);
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,
 
266
extern int mi_rfirst(struct st_myisam_info *file,unsigned char *buf,int inx);
 
267
extern int mi_rkey(MI_INFO *info, unsigned char *buf, int inx, const unsigned char *key,
268
268
                   key_part_map keypart_map, enum ha_rkey_function search_flag);
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);
 
269
extern int mi_rlast(struct st_myisam_info *file,unsigned char *buf,int inx);
 
270
extern int mi_rnext(struct st_myisam_info *file,unsigned char *buf,int inx);
 
271
extern int mi_rnext_same(struct st_myisam_info *info, unsigned char *buf);
 
272
extern int mi_rprev(struct st_myisam_info *file,unsigned char *buf,int inx);
 
273
extern int mi_rrnd(struct st_myisam_info *file,unsigned char *buf, my_off_t pos);
274
274
extern int mi_scan_init(struct st_myisam_info *file);
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,
278
 
                             int inx, my_off_t pos);
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);
 
275
extern int mi_scan(struct st_myisam_info *file,unsigned char *buf);
 
276
extern int mi_rsame(struct st_myisam_info *file,unsigned char *record,int inx);
 
277
extern int mi_update(struct st_myisam_info *file,const unsigned char *old,
 
278
                     unsigned char *new_record);
 
279
extern int mi_write(struct st_myisam_info *file,unsigned char *buff);
282
280
extern my_off_t mi_position(struct st_myisam_info *file);
283
 
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint flag);
 
281
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint32_t flag);
284
282
extern int mi_lock_database(struct st_myisam_info *file,int lock_type);
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);
 
283
extern int mi_create(const char *name,uint32_t keys,MI_KEYDEF *keydef,
 
284
                     uint32_t columns, MI_COLUMNDEF *columndef,
 
285
                     uint32_t uniques, MI_UNIQUEDEF *uniquedef,
 
286
                     MI_CREATE_INFO *create_info, uint32_t flags);
289
287
extern int mi_delete_table(const char *name);
290
288
extern int mi_rename(const char *from, const char *to);
291
289
extern int mi_extra(struct st_myisam_info *file,
295
293
extern ha_rows mi_records_in_range(MI_INFO *info, int inx,
296
294
                                   key_range *min_key, key_range *max_key);
297
295
extern int mi_log(int activate_log);
298
 
extern int mi_is_changed(struct st_myisam_info *info);
299
296
extern int mi_delete_all_rows(struct st_myisam_info *info);
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);
 
297
extern ulong _mi_calc_blob_length(uint32_t length , const unsigned char *pos);
 
298
extern uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def);
302
299
 
303
300
/* this is used to pass to mysql_myisamchk_table */
304
301
 
350
347
 
351
348
#define T_REP_ANY               (T_REP | T_REP_BY_SORT | T_REP_PARALLEL)
352
349
 
353
 
/*
354
 
  Flags used by myisamchk.c or/and ha_myisam.cc that are NOT passed
355
 
  to mi_check.c follows:
356
 
*/
357
 
 
358
 
#define TT_USEFRM               1
359
 
#define TT_FOR_UPGRADE          2
360
 
 
361
350
#define O_NEW_INDEX     1               /* Bits set in out_flag */
362
351
#define O_NEW_DATA      2
363
352
#define O_DATA_LOST     4
366
355
 
367
356
typedef struct st_sort_key_blocks               /* Used when sorting */
368
357
{
369
 
  uchar *buff,*end_pos;
370
 
  uchar lastkey[MI_MAX_POSSIBLE_KEY_BUFF];
371
 
  uint last_length;
 
358
  unsigned char *buff,*end_pos;
 
359
  unsigned char lastkey[MI_MAX_POSSIBLE_KEY_BUFF];
 
360
  uint32_t last_length;
372
361
  int inited;
373
362
} SORT_KEY_BLOCKS;
374
363
 
375
364
 
376
 
/* 
377
 
  MyISAM supports several statistics collection methods. Currently statistics 
378
 
  collection method is not stored in MyISAM file and has to be specified for 
 
365
/*
 
366
  MyISAM supports several statistics collection methods. Currently statistics
 
367
  collection method is not stored in MyISAM file and has to be specified for
379
368
  each table analyze/repair operation in  MI_CHECK::stats_method.
380
369
*/
381
370
 
382
 
typedef enum 
 
371
typedef enum
383
372
{
384
373
  /* Treat NULLs as inequal when collecting statistics (default for 4.1/5.0) */
385
374
  MI_STATS_METHOD_NULLS_NOT_EQUAL,
400
389
  my_off_t keydata,totaldata,key_blocks,start_check_pos;
401
390
  ha_rows total_records,total_deleted;
402
391
  ha_checksum record_checksum,glob_crc;
403
 
  ulong use_buffers,read_buffer_length,write_buffer_length,
404
 
        sort_buffer_length,sort_key_blocks;
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;
 
392
  uint64_t use_buffers;
 
393
  size_t read_buffer_length, write_buffer_length,
 
394
         sort_buffer_length, sort_key_blocks;
 
395
  uint32_t out_flag,warning_printed,error_printed,verbose;
 
396
  uint32_t opt_sort_key,total_files,max_level;
 
397
  uint32_t testflag, key_cache_block_size;
408
398
  uint8_t language;
409
 
  my_bool using_global_keycache, opt_lock_memory, opt_follow_links;
410
 
  my_bool retry_repair, force_sort;
 
399
  bool using_global_keycache, opt_lock_memory, opt_follow_links;
 
400
  bool retry_repair, force_sort;
411
401
  char temp_filename[FN_REFLEN],*isam_file_name;
412
 
  MY_TMPDIR *tmpdir;
413
402
  int tmpfile_createflag;
414
403
  myf myf_rw;
415
404
  IO_CACHE read_cache;
416
 
  
417
 
  /* 
 
405
 
 
406
  /*
418
407
    The next two are used to collect statistics, see update_key_parts for
419
408
    description.
420
409
  */
421
410
  uint64_t unique_count[MI_MAX_KEY_SEG+1];
422
411
  uint64_t notnull_count[MI_MAX_KEY_SEG+1];
423
 
  
 
412
 
424
413
  ha_checksum key_crc[HA_MAX_POSSIBLE_KEY];
425
414
  ulong rec_per_key_part[MI_MAX_KEY_SEG*HA_MAX_POSSIBLE_KEY];
426
 
  void *thd;
 
415
  void *session;
427
416
  const char *db_name, *table_name;
428
417
  const char *op_name;
429
418
  enum_mi_stats_method stats_method;
433
422
{
434
423
  my_off_t filelength,dupp,buff_length;
435
424
  ha_rows max_records;
436
 
  uint current_key, total_keys;
 
425
  uint32_t current_key, total_keys;
437
426
  myf myf_rw;
438
427
  enum data_file_type new_data_file_type;
439
428
  MI_INFO *info;
440
429
  MI_CHECK *param;
441
 
  uchar *buff;
 
430
  unsigned char *buff;
442
431
  SORT_KEY_BLOCKS *key_block,*key_block_end;
443
432
  /* sync things */
444
 
  uint got_error, threads_running;
 
433
  uint32_t got_error, threads_running;
445
434
  pthread_mutex_t mutex;
446
435
  pthread_cond_t  cond;
447
436
} SORT_INFO;
449
438
/* functions in mi_check */
450
439
void myisamchk_init(MI_CHECK *param);
451
440
int chk_status(MI_CHECK *param, MI_INFO *info);
452
 
int chk_del(MI_CHECK *param, register MI_INFO *info, uint test_flag);
 
441
int chk_del(MI_CHECK *param, register MI_INFO *info, uint32_t test_flag);
453
442
int chk_size(MI_CHECK *param, MI_INFO *info);
454
443
int chk_key(MI_CHECK *param, MI_INFO *info);
455
444
int chk_data_link(MI_CHECK *param, MI_INFO *info,int extend);
461
450
int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info,
462
451
                      const char * name, int rep_quick);
463
452
int change_to_newfile(const char * filename, const char * old_ext,
464
 
                      const char * new_ext, uint raid_chunks,
 
453
                      const char * new_ext, uint32_t raid_chunks,
465
454
                      myf myflags);
466
455
void lock_memory(MI_CHECK *param);
467
456
void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,
468
 
                               my_bool repair);
469
 
int update_state_info(MI_CHECK *param, MI_INFO *info,uint update);
 
457
                               bool repair);
 
458
int update_state_info(MI_CHECK *param, MI_INFO *info,uint32_t update);
470
459
void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,
471
 
                      uint64_t *unique, uint64_t *notnull, 
 
460
                      uint64_t *unique, uint64_t *notnull,
472
461
                      uint64_t records);
473
 
int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
 
462
int filecopy(MI_CHECK *param, int to,int from,my_off_t start,
474
463
             my_off_t length, const char *type);
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);
 
464
int movepoint(MI_INFO *info,unsigned char *record,my_off_t oldpos,
 
465
              my_off_t newpos, uint32_t prot_key);
 
466
int write_data_suffix(SORT_INFO *sort_info, bool fix_datafile);
478
467
int test_if_almost_full(MI_INFO *info);
479
468
int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename);
480
 
my_bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, uint64_t key_map,
481
 
                            my_bool force);
 
469
bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, uint64_t key_map,
 
470
                            bool force);
482
471
 
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);
 
472
int mi_init_bulk_insert(MI_INFO *info, uint32_t cache_size, ha_rows rows);
 
473
void mi_flush_bulk_insert(MI_INFO *info, uint32_t inx);
485
474
void mi_end_bulk_insert(MI_INFO *info);
486
 
int mi_assign_to_key_cache(MI_INFO *info, uint64_t key_map, 
487
 
                           KEY_CACHE *key_cache);
488
 
void mi_change_key_cache(KEY_CACHE *old_key_cache,
489
 
                         KEY_CACHE *new_key_cache);
490
 
int mi_preload(MI_INFO *info, uint64_t key_map, my_bool ignore_leaves);
 
475
int mi_preload(MI_INFO *info, uint64_t key_map, bool ignore_leaves);
491
476
 
492
477
#ifdef  __cplusplus
493
478
}
494
479
#endif
495
 
#endif
 
480
#endif /* PLUGIN_MYISAM_MYISAM_H */