← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/myisam.h

  • Committer: Jay Pipes
  • Date: 2008-09-11 16:03:22 UTC
  • mto: (383.5.1 trunk)
  • mto: This revision was merged to the branch mainline in revision 386.
  • Revision ID: jay@mysql.com-20080911160322-vrl0k1djo6q6ytv1
Removed SQL_MODE variances from comment_table.test and ensured correct error thrown when a comment that is too long was input.  After moving to proto buffer definition for table, the 2048 length will go away.

Show diffs side-by-side

added added

removed removed

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