← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/myisamdef.h

merge mainline

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/myisamdef.h
15
15
 
16
16
/* This file is included by all internal myisam files */
17
17
 
18
 
#ifndef MYISAMDEF_H
 
18
#if !defined(MYISAMDEF_H)
19
19
#define MYISAMDEF_H
20
20
 
21
21
#include "myisam.h"                     /* Structs & some defines */
22
22
#include "myisampack.h"                 /* packing of keys */
23
 
#include <mysys/my_tree.h>
24
 
#include <mysys/my_pthread.h>
25
 
#include <mysys/thr_lock.h>
26
 
#include <libdrizzle/drizzle_com.h>
 
23
#include <my_tree.h>
 
24
#include <my_pthread.h>
 
25
#include <thr_lock.h>
27
26
 
28
 
#if defined(my_write)
 
27
#if defined(my_write) && !defined(MAP_TO_USE_RAID)
29
28
#undef my_write                         /* undef map from my_nosys; We need test-if-disk full */
30
29
#endif
31
30
 
43
42
typedef struct st_mi_state_info
44
43
{
45
44
  struct {                              /* Fileheader */
46
 
    unsigned char file_version[4];
47
 
    unsigned char options[2];
48
 
    unsigned char header_length[2];
49
 
    unsigned char state_info_length[2];
50
 
    unsigned char base_info_length[2];
51
 
    unsigned char base_pos[2];
52
 
    unsigned char key_parts[2];                 /* Key parts */
53
 
    unsigned char unique_key_parts[2];          /* Key parts + unique parts */
54
 
    unsigned char keys;                         /* number of keys in file */
55
 
    unsigned char uniques;                      /* number of UNIQUE definitions */
56
 
    unsigned char language;                     /* Language for indexes */
57
 
    unsigned char max_block_size_index;         /* max keyblock size */
58
 
    unsigned char fulltext_keys;
59
 
    unsigned char not_used;                     /* To align to 8 */
 
45
    uchar file_version[4];
 
46
    uchar options[2];
 
47
    uchar header_length[2];
 
48
    uchar state_info_length[2];
 
49
    uchar base_info_length[2];
 
50
    uchar base_pos[2];
 
51
    uchar key_parts[2];                 /* Key parts */
 
52
    uchar unique_key_parts[2];          /* Key parts + unique parts */
 
53
    uchar keys;                         /* number of keys in file */
 
54
    uchar uniques;                      /* number of UNIQUE definitions */
 
55
    uchar language;                     /* Language for indexes */
 
56
    uchar max_block_size_index;         /* max keyblock size */
 
57
    uchar fulltext_keys;
 
58
    uchar not_used;                     /* To align to 8 */
60
59
  } header;
61
60
 
62
61
  MI_STATUS_INFO state;
63
62
  ha_rows split;                        /* number of split blocks */
64
63
  my_off_t dellink;                     /* Link to next removed block */
65
 
  uint64_t auto_increment;
 
64
  ulonglong auto_increment;
66
65
  ulong process;                        /* process that updated table last */
67
66
  ulong unique;                         /* Unique number for this process */
68
67
  ulong update_count;                   /* Updated for each write lock */
74
73
 
75
74
  ulong sec_index_changed;              /* Updated when new sec_index */
76
75
  ulong sec_index_used;                 /* which extra index are in use */
77
 
  uint64_t key_map;                     /* Which keys are in use */
 
76
  ulonglong key_map;                    /* Which keys are in use */
78
77
  ha_checksum checksum;                 /* Table checksum */
79
78
  ulong version;                        /* timestamp of create */
80
79
  time_t create_time;                   /* Time when created database */
81
80
  time_t recover_time;                  /* Time for last recover */
82
81
  time_t check_time;                    /* Time for last check */
83
82
  uint  sortkey;                        /* sorted by this key  (not used) */
84
 
  uint32_t open_count;
85
 
  uint8_t changed;                      /* Changed since myisamchk */
 
83
  uint open_count;
 
84
  uint8 changed;                        /* Changed since myisamchk */
86
85
 
87
86
  /* the following isn't saved on disk */
88
 
  uint32_t state_diff_length;           /* Should be 0 */
 
87
  uint state_diff_length;               /* Should be 0 */
89
88
  uint  state_length;                   /* Length of state header in file */
90
89
  ulong *key_info;
91
90
} MI_STATE_INFO;
117
116
  ulong min_block_length;
118
117
  ulong fields,                         /* fields in table */
119
118
       pack_fields;                     /* packed fields in table */
120
 
  uint32_t rec_reflength;                       /* = 2-8 */
121
 
  uint32_t key_reflength;                       /* = 2-8 */
122
 
  uint32_t keys;                                /* same as in state.header */
123
 
  uint32_t auto_key;                    /* Which key-1 is a auto key */
124
 
  uint32_t blobs;                               /* Number of blobs */
125
 
  uint32_t pack_bits;                   /* Length of packed bits */
126
 
  uint32_t max_key_block_length;                /* Max block length */
127
 
  uint32_t max_key_length;                      /* Max key length */
 
119
  uint rec_reflength;                   /* = 2-8 */
 
120
  uint key_reflength;                   /* = 2-8 */
 
121
  uint keys;                            /* same as in state.header */
 
122
  uint auto_key;                        /* Which key-1 is a auto key */
 
123
  uint blobs;                           /* Number of blobs */
 
124
  uint pack_bits;                       /* Length of packed bits */
 
125
  uint max_key_block_length;            /* Max block length */
 
126
  uint max_key_length;                  /* Max key length */
128
127
  /* Extra allocation when using dynamic record format */
129
 
  uint32_t extra_alloc_bytes;
130
 
  uint32_t extra_alloc_procent;
 
128
  uint extra_alloc_bytes;
 
129
  uint extra_alloc_procent;
131
130
  /* Info about raid */
132
 
  uint32_t raid_type,raid_chunks;
133
 
  uint32_t raid_chunksize;
 
131
  uint raid_type,raid_chunks;
 
132
  ulong raid_chunksize;
134
133
  /* The following are from the header */
135
 
  uint32_t key_parts,all_key_parts;
 
134
  uint key_parts,all_key_parts;
136
135
} MI_BASE_INFO;
137
136
 
138
137
 
141
140
typedef struct st_mi_blob               /* Info of record */
142
141
{
143
142
  ulong offset;                         /* Offset to blob in record */
144
 
  uint32_t pack_length;                 /* Type of packed length */
 
143
  uint pack_length;                     /* Type of packed length */
145
144
  ulong length;                         /* Calc:ed for each record */
146
145
} MI_BLOB;
147
146
 
148
147
 
149
148
typedef struct st_mi_isam_pack {
150
149
  ulong header_length;
151
 
  uint32_t ref_length;
152
 
  unsigned char version;
 
150
  uint ref_length;
 
151
  uchar version;
153
152
} MI_PACK;
154
153
 
155
154
#define MAX_NONMAPPED_INSERTS 1000      
168
167
  char  *unique_file_name;              /* realpath() of index file */
169
168
  char  *data_file_name,                /* Resolved path names from symlinks */
170
169
        *index_file_name;
171
 
  unsigned char *file_map;                      /* mem-map of file if possible */
 
170
  uchar *file_map;                      /* mem-map of file if possible */
172
171
  KEY_CACHE *key_cache;                 /* ref to the current key cache */
173
172
  MI_DECODE_TREE *decode_trees;
174
 
  uint16_t *decode_tables;
175
 
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
176
 
  int (*write_record)(struct st_myisam_info*, const unsigned char*);
177
 
  int (*update_record)(struct st_myisam_info*, my_off_t, const unsigned char*);
 
173
  uint16 *decode_tables;
 
174
  int (*read_record)(struct st_myisam_info*, my_off_t, uchar*);
 
175
  int (*write_record)(struct st_myisam_info*, const uchar*);
 
176
  int (*update_record)(struct st_myisam_info*, my_off_t, const uchar*);
178
177
  int (*delete_record)(struct st_myisam_info*);
179
 
  int (*read_rnd)(struct st_myisam_info*, unsigned char*, my_off_t, bool);
180
 
  int (*compare_record)(struct st_myisam_info*, const unsigned char *);
 
178
  int (*read_rnd)(struct st_myisam_info*, uchar*, my_off_t, my_bool);
 
179
  int (*compare_record)(struct st_myisam_info*, const uchar *);
181
180
  /* Function to use for a row checksum. */
182
 
  ha_checksum (*calc_checksum)(struct st_myisam_info*, const unsigned char *);
 
181
  ha_checksum (*calc_checksum)(struct st_myisam_info*, const uchar *);
183
182
  int (*compare_unique)(struct st_myisam_info*, MI_UNIQUEDEF *,
184
 
                        const unsigned char *record, my_off_t pos);
185
 
  size_t (*file_read)(MI_INFO *, unsigned char *, size_t, my_off_t, myf);
186
 
  size_t (*file_write)(MI_INFO *, const unsigned char *, size_t, my_off_t, myf);
 
183
                        const uchar *record, my_off_t pos);
 
184
  size_t (*file_read)(MI_INFO *, uchar *, size_t, my_off_t, myf);
 
185
  size_t (*file_write)(MI_INFO *, const uchar *, size_t, my_off_t, myf);
187
186
  invalidator_by_filename invalidator;  /* query cache invalidator */
188
187
  ulong this_process;                   /* processid */
189
188
  ulong last_process;                   /* For table-change-check */
193
192
  ulong max_pack_length;
194
193
  ulong state_diff_length;
195
194
  uint  rec_reflength;                  /* rec_reflength in use now */
196
 
  uint32_t  unique_name_length;
 
195
  uint  unique_name_length;
197
196
  File  kfile;                          /* Shared keyfile */
198
197
  File  data_file;                      /* Shared data file */
199
198
  int   mode;                           /* mode of file on open */
203
202
  myf write_flag;
204
203
  enum data_file_type data_file_type;
205
204
  /* Below flag is needed to make log tables work with concurrent insert */
206
 
  bool is_log_table;
 
205
  my_bool is_log_table;
207
206
 
208
 
  bool  changed,                        /* If changed since lock */
 
207
  my_bool  changed,                     /* If changed since lock */
209
208
    global_changed,                     /* If changed since open */
210
209
    not_flushed,
211
210
    temporary,delay_key_write,
214
213
  pthread_mutex_t intern_lock;          /* Locking for use with _locking */
215
214
  rw_lock_t *key_root_lock;
216
215
  my_off_t mmaped_length;
217
 
  uint32_t     nonmmaped_inserts;           /* counter of writing in non-mmaped
 
216
  uint     nonmmaped_inserts;           /* counter of writing in non-mmaped
218
217
                                           area */
219
218
  rw_lock_t mmap_lock;
220
219
} MYISAM_SHARE;
221
220
 
222
221
 
223
 
typedef uint32_t mi_bit_type;
 
222
typedef uint mi_bit_type;
224
223
 
225
224
typedef struct st_mi_bit_buff {         /* Used for packing of record */
226
225
  mi_bit_type current_byte;
227
 
  uint32_t bits;
228
 
  unsigned char *pos,*end,*blob_pos,*blob_end;
229
 
  uint32_t error;
 
226
  uint bits;
 
227
  uchar *pos,*end,*blob_pos,*blob_end;
 
228
  uint error;
230
229
} MI_BIT_BUFF;
231
230
 
232
231
 
233
 
typedef bool (*index_cond_func_t)(void *param);
 
232
typedef my_bool (*index_cond_func_t)(void *param);
234
233
 
235
234
struct st_myisam_info {
236
235
  MYISAM_SHARE *s;                      /* Shared between open:s */
241
240
  TREE          *bulk_insert;
242
241
  LIST in_use;                          /* Thread using this table          */
243
242
  char *filename;                       /* parameter to open filename       */
244
 
  unsigned char *buff,                          /* Temp area for key                */
 
243
  uchar *buff,                          /* Temp area for key                */
245
244
        *lastkey,*lastkey2;             /* Last used search key             */
246
 
  unsigned char *first_mbr_key;                 /* Searhed spatial key              */
247
 
  unsigned char *rec_buff;                      /* Tempbuff for recordpack          */
248
 
  unsigned char *int_keypos,                    /* Save position for next/previous  */
 
245
  uchar *first_mbr_key;                 /* Searhed spatial key              */
 
246
  uchar *rec_buff;                      /* Tempbuff for recordpack          */
 
247
  uchar *int_keypos,                    /* Save position for next/previous  */
249
248
        *int_maxpos;                    /*  -""-  */
250
 
  uint32_t  int_nod_flag;                       /*  -""-  */
251
 
  uint32_t int_keytree_version;         /*  -""-  */
252
 
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
 
249
  uint  int_nod_flag;                   /*  -""-  */
 
250
  uint32 int_keytree_version;           /*  -""-  */
 
251
  int (*read_record)(struct st_myisam_info*, my_off_t, uchar*);
253
252
  invalidator_by_filename invalidator;  /* query cache invalidator */
254
253
  ulong this_unique;                    /* uniq filenumber or thread */
255
254
  ulong last_unique;                    /* last unique number */
267
266
     as they are not compatible with parallel repair */
268
267
  ulong packed_length,blob_length;      /* Length of found, packed record */
269
268
  int  dfile;                           /* The datafile */
270
 
  uint32_t opt_flag;                    /* Optim. for space/speed */
271
 
  uint32_t update;                              /* If file changed since open */
 
269
  uint opt_flag;                        /* Optim. for space/speed */
 
270
  uint update;                          /* If file changed since open */
272
271
  int   lastinx;                        /* Last used index */
273
272
  uint  lastkey_length;                 /* Length of key in lastkey */
274
273
  uint  last_rkey_length;               /* Last length in mi_rkey() */
275
274
  enum ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
276
 
  uint32_t  save_lastkey_length;
277
 
  uint32_t  pack_key_length;                /* For MYISAMMRG */
278
 
  uint16_t last_used_keyseg;              /* For MyISAMMRG */
 
275
  uint  save_lastkey_length;
 
276
  uint  pack_key_length;                /* For MYISAMMRG */
 
277
  uint16 last_used_keyseg;              /* For MyISAMMRG */
279
278
  int   errkey;                         /* Got last error on this key */
280
279
  int   lock_type;                      /* How database was locked */
281
280
  int   tmp_lock_type;                  /* When locked by readinfo */
284
283
  int   save_lastinx;
285
284
  LIST  open_list;
286
285
  IO_CACHE rec_cache;                   /* When cacheing records */
287
 
  uint32_t  preload_buff_size;              /* When preloading indexes */
 
286
  uint  preload_buff_size;              /* When preloading indexes */
288
287
  myf lock_wait;                        /* is 0 or MY_DONT_WAIT */
289
 
  bool was_locked;                      /* Was locked in panic */
290
 
  bool append_insert_at_end;            /* Set if concurrent insert */
291
 
  bool quick_mode;
292
 
  bool page_changed;            /* If info->buff can't be used for rnext */
293
 
  bool buff_used;               /* If info->buff has to be reread for rnext */
294
 
  bool once_flags;           /* For MYISAMMRG */
 
288
  my_bool was_locked;                   /* Was locked in panic */
 
289
  my_bool append_insert_at_end;         /* Set if concurrent insert */
 
290
  my_bool quick_mode;
 
291
  my_bool page_changed;         /* If info->buff can't be used for rnext */
 
292
  my_bool buff_used;            /* If info->buff has to be reread for rnext */
 
293
  my_bool once_flags;           /* For MYISAMMRG */
295
294
 
296
295
  index_cond_func_t index_cond_func;   /* Index condition function */
297
296
  void *index_cond_func_arg;           /* parameter for the func */
 
297
#ifdef __WIN__
 
298
  my_bool owned_by_merge;                       /* This MyISAM table is part of a merge union */
 
299
#endif
298
300
  THR_LOCK_DATA lock;
299
 
  unsigned char  *rtree_recursion_state;        /* For RTREE */
 
301
  uchar  *rtree_recursion_state;        /* For RTREE */
300
302
  int     rtree_recursion_depth;
301
303
};
302
304
 
303
305
typedef struct st_buffpek {
304
306
  my_off_t file_pos;                    /* Where we are in the sort file */
305
 
  unsigned char *base,*key;                     /* Key pointers */
 
307
  uchar *base,*key;                     /* Key pointers */
306
308
  ha_rows count;                        /* Number of rows in table */
307
309
  ulong mem_count;                      /* numbers of keys in memory */
308
310
  ulong max_keys;                       /* Max keys in buffert */
319
321
    The next two are used to collect statistics, see update_key_parts for
320
322
    description.
321
323
  */
322
 
  uint64_t unique[MI_MAX_KEY_SEG+1];
323
 
  uint64_t notnull[MI_MAX_KEY_SEG+1];
 
324
  ulonglong unique[MI_MAX_KEY_SEG+1];
 
325
  ulonglong notnull[MI_MAX_KEY_SEG+1];
324
326
 
325
327
  my_off_t pos,max_pos,filepos,start_recpos;
326
 
  uint32_t key, key_length,real_key_length,sortbuff_size;
327
 
  uint32_t maxbuffers, keys, find_length, sort_keys_length;
328
 
  bool fix_datafile, master;
329
 
  bool calc_checksum;                /* calculate table checksum */
 
328
  uint key, key_length,real_key_length,sortbuff_size;
 
329
  uint maxbuffers, keys, find_length, sort_keys_length;
 
330
  my_bool fix_datafile, master;
 
331
  my_bool calc_checksum;                /* calculate table checksum */
330
332
  MI_KEYDEF *keyinfo;
331
333
  HA_KEYSEG *seg;
332
334
  SORT_INFO *sort_info;
333
 
  unsigned char **sort_keys;
334
 
  unsigned char *rec_buff;
 
335
  uchar **sort_keys;
 
336
  uchar *rec_buff;
335
337
  void *wordlist, *wordptr;
336
338
  MEM_ROOT wordroot;
337
 
  unsigned char *record;
 
339
  uchar *record;
338
340
  MY_TMPDIR *tmpdir;
339
341
  int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *);
340
342
  int (*key_read)(struct st_mi_sort_param *,void *);
341
343
  int (*key_write)(struct st_mi_sort_param *, const void *);
342
344
  void (*lock_in_memory)(MI_CHECK *);
343
 
  int (*write_keys)(struct st_mi_sort_param *, register unsigned char **,
344
 
                     uint32_t , struct st_buffpek *, IO_CACHE *);
 
345
  int (*write_keys)(struct st_mi_sort_param *, register uchar **,
 
346
                     uint , struct st_buffpek *, IO_CACHE *);
345
347
  unsigned int (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
346
 
  int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,unsigned char *,
 
348
  int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,uchar *,
347
349
                       uint, uint);
348
350
} MI_SORT_PARAM;
349
351
 
377
379
#define READING_NEXT    1
378
380
#define READING_HEADER  2
379
381
 
380
 
 
381
382
#define mi_getint(x)    ((uint) mi_uint2korr(x) & 32767)
382
 
#define mi_putint(x,y,nod) { uint16_t boh=(nod ? (uint16_t) 32768 : 0) + (uint16_t) (y);\
 
383
#define mi_putint(x,y,nod) { uint16 boh=(nod ? (uint16) 32768 : 0) + (uint16) (y);\
383
384
                          mi_int2store(x,boh); }
384
385
#define mi_test_if_nod(x) (x[0] & 128 ? info->s->base.key_reflength : 0)
385
386
#define mi_report_crashed(A, B) _mi_report_crashed((A), (B), __FILE__, __LINE__)
386
387
#define mi_mark_crashed(x) do{(x)->s->state.changed|= STATE_CRASHED; \
 
388
                              DBUG_PRINT("error", ("Marked table crashed")); \
387
389
                              mi_report_crashed((x), 0); \
388
390
                           }while(0)
389
391
#define mi_mark_crashed_on_repair(x) do{(x)->s->state.changed|= \
390
392
                                        STATE_CRASHED|STATE_CRASHED_ON_REPAIR; \
391
393
                                        (x)->update|= HA_STATE_CHANGED; \
 
394
                                        DBUG_PRINT("error", \
 
395
                                                   ("Marked table crashed")); \
392
396
                                     }while(0)
393
397
#define mi_is_crashed(x) ((x)->s->state.changed & STATE_CRASHED)
394
398
#define mi_is_crashed_on_repair(x) ((x)->s->state.changed & STATE_CRASHED_ON_REPAIR)
395
399
#define mi_print_error(SHARE, ERRNO)                     \
396
400
        mi_report_error((ERRNO), (SHARE)->index_file_name)
397
401
 
 
402
C_MODE_START
 
403
void _mi_report_crashed(MI_INFO *file __attribute__((unused)),
 
404
                        const char *message __attribute__((unused)),
 
405
                        const char *sfile __attribute__((unused)),
 
406
                        uint sline __attribute__((unused)));
 
407
C_MODE_END
398
408
/* Functions to store length of space packed keys, VARCHAR or BLOB keys */
399
409
 
400
410
#define store_key_length(key,length) \
405
415
}
406
416
 
407
417
#define get_key_full_length(length,key) \
408
 
{ if ((unsigned char) *(key) != 255) \
409
 
    length= ((uint) (unsigned char) *((key)++))+1; \
 
418
{ if ((uchar) *(key) != 255) \
 
419
    length= ((uint) (uchar) *((key)++))+1; \
410
420
  else \
411
421
  { length=mi_uint2korr((key)+1)+3; (key)+=3; } \
412
422
}
413
423
 
414
424
#define get_key_full_length_rdonly(length,key) \
415
 
{ if ((unsigned char) *(key) != 255) \
416
 
    length= ((uint) (unsigned char) *((key)))+1; \
 
425
{ if ((uchar) *(key) != 255) \
 
426
    length= ((uint) (uchar) *((key)))+1; \
417
427
  else \
418
428
  { length=mi_uint2korr((key)+1)+3; } \
419
429
}
431
441
#define MI_DYN_ALIGN_SIZE       4       /* Align blocks on this */
432
442
#define MI_MAX_DYN_HEADER_BYTE  13      /* max header byte for dynamic rows */
433
443
#define MI_MAX_BLOCK_LENGTH     ((((ulong) 1 << 24)-1) & (~ (ulong) (MI_DYN_ALIGN_SIZE-1)))
434
 
#define MI_REC_BUFF_OFFSET      ALIGN_SIZE(MI_DYN_DELETE_BLOCK_HEADER+sizeof(uint32_t))
 
444
#define MI_REC_BUFF_OFFSET      ALIGN_SIZE(MI_DYN_DELETE_BLOCK_HEADER+sizeof(uint32))
435
445
 
436
446
#define MEMMAP_EXTRA_MARGIN     7       /* Write this as a suffix for file */
437
447
 
460
470
        /* Some extern variables */
461
471
 
462
472
extern LIST *myisam_open_list;
463
 
extern unsigned char  myisam_file_magic[], myisam_pack_file_magic[];
464
 
extern uint32_t  myisam_read_vec[], myisam_readnext_vec[];
465
 
extern uint32_t myisam_quick_table_bits;
 
473
extern uchar  myisam_file_magic[], myisam_pack_file_magic[];
 
474
extern uint  myisam_read_vec[], myisam_readnext_vec[];
 
475
extern uint myisam_quick_table_bits;
 
476
extern File myisam_log_file;
466
477
extern ulong myisam_pid;
467
478
 
468
479
        /* This is used by _mi_calc_xxx_key_length och _mi_store_key */
474
485
        n_length,
475
486
        totlength,
476
487
        part_of_prev_key,prev_length,pack_marker;
477
 
  unsigned char *key, *prev_key,*next_key_pos;
478
 
  bool store_not_null;
 
488
  uchar *key, *prev_key,*next_key_pos;
 
489
  my_bool store_not_null;
479
490
} MI_KEY_PARAM;
480
491
 
481
492
        /* Prototypes for intern functions */
482
493
 
483
 
extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
484
 
extern int _mi_write_dynamic_record(MI_INFO*, const unsigned char*);
485
 
extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const unsigned char*);
 
494
extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,uchar *buf);
 
495
extern int _mi_write_dynamic_record(MI_INFO*, const uchar*);
 
496
extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const uchar*);
486
497
extern int _mi_delete_dynamic_record(MI_INFO *info);
487
 
extern int _mi_cmp_dynamic_record(MI_INFO *info,const unsigned char *record);
488
 
extern int _mi_read_rnd_dynamic_record(MI_INFO *, unsigned char *,my_off_t, bool);
489
 
extern int _mi_write_blob_record(MI_INFO*, const unsigned char*);
490
 
extern int _mi_update_blob_record(MI_INFO*, my_off_t, const unsigned char*);
491
 
extern int _mi_read_static_record(MI_INFO *info, my_off_t filepos,unsigned char *buf);
492
 
extern int _mi_write_static_record(MI_INFO*, const unsigned char*);
493
 
extern int _mi_update_static_record(MI_INFO*, my_off_t, const unsigned char*);
 
498
extern int _mi_cmp_dynamic_record(MI_INFO *info,const uchar *record);
 
499
extern int _mi_read_rnd_dynamic_record(MI_INFO *, uchar *,my_off_t, my_bool);
 
500
extern int _mi_write_blob_record(MI_INFO*, const uchar*);
 
501
extern int _mi_update_blob_record(MI_INFO*, my_off_t, const uchar*);
 
502
extern int _mi_read_static_record(MI_INFO *info, my_off_t filepos,uchar *buf);
 
503
extern int _mi_write_static_record(MI_INFO*, const uchar*);
 
504
extern int _mi_update_static_record(MI_INFO*, my_off_t, const uchar*);
494
505
extern int _mi_delete_static_record(MI_INFO *info);
495
 
extern int _mi_cmp_static_record(MI_INFO *info,const unsigned char *record);
496
 
extern int _mi_read_rnd_static_record(MI_INFO*, unsigned char *,my_off_t, bool);
497
 
extern int _mi_ck_write(MI_INFO *info,uint32_t keynr,unsigned char *key,uint32_t length);
 
506
extern int _mi_cmp_static_record(MI_INFO *info,const uchar *record);
 
507
extern int _mi_read_rnd_static_record(MI_INFO*, uchar *,my_off_t, my_bool);
 
508
extern int _mi_ck_write(MI_INFO *info,uint keynr,uchar *key,uint length);
498
509
extern int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
499
 
                                   unsigned char *key, uint32_t key_length,
500
 
                                   my_off_t *root, uint32_t comp_flag);
501
 
extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key, my_off_t *root);
502
 
extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
503
 
                      unsigned char *anc_buff,unsigned char *key_pos,unsigned char *key_buff,
504
 
                      unsigned char *father_buff, unsigned char *father_keypos,
505
 
                      my_off_t father_page, bool insert_last);
506
 
extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
507
 
                          unsigned char *buff,unsigned char *key_buff, bool insert_last);
508
 
extern unsigned char *_mi_find_half_pos(uint32_t nod_flag,MI_KEYDEF *keyinfo,unsigned char *page,
509
 
                                unsigned char *key,uint32_t *return_key_length,
510
 
                                unsigned char **after_key);
511
 
extern int _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
512
 
                                      unsigned char *key_pos, unsigned char *org_key,
513
 
                                      unsigned char *key_buff,
514
 
                                      unsigned char *key, MI_KEY_PARAM *s_temp);
515
 
extern int _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
516
 
                                   unsigned char *key_pos, unsigned char *org_key,
517
 
                                   unsigned char *key_buff,
518
 
                                   unsigned char *key, MI_KEY_PARAM *s_temp);
519
 
extern int _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
520
 
                                        unsigned char *key_pos, unsigned char *org_key,
521
 
                                        unsigned char *prev_key,
522
 
                                        unsigned char *key, MI_KEY_PARAM *s_temp);
523
 
extern int _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint32_t nod_flag,
524
 
                                        unsigned char *key_pos,unsigned char *org_key,
525
 
                                        unsigned char *prev_key,
526
 
                                        unsigned char *key, MI_KEY_PARAM *s_temp);
527
 
void _mi_store_static_key(MI_KEYDEF *keyinfo,  unsigned char *key_pos,
 
510
                                   uchar *key, uint key_length,
 
511
                                   my_off_t *root, uint comp_flag);
 
512
extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key, my_off_t *root);
 
513
extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
 
514
                      uchar *anc_buff,uchar *key_pos,uchar *key_buff,
 
515
                      uchar *father_buff, uchar *father_keypos,
 
516
                      my_off_t father_page, my_bool insert_last);
 
517
extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
 
518
                          uchar *buff,uchar *key_buff, my_bool insert_last);
 
519
extern uchar *_mi_find_half_pos(uint nod_flag,MI_KEYDEF *keyinfo,uchar *page,
 
520
                                uchar *key,uint *return_key_length,
 
521
                                uchar **after_key);
 
522
extern int _mi_calc_static_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
523
                                      uchar *key_pos, uchar *org_key,
 
524
                                      uchar *key_buff,
 
525
                                      uchar *key, MI_KEY_PARAM *s_temp);
 
526
extern int _mi_calc_var_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
527
                                   uchar *key_pos, uchar *org_key,
 
528
                                   uchar *key_buff,
 
529
                                   uchar *key, MI_KEY_PARAM *s_temp);
 
530
extern int _mi_calc_var_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
531
                                        uchar *key_pos, uchar *org_key,
 
532
                                        uchar *prev_key,
 
533
                                        uchar *key, MI_KEY_PARAM *s_temp);
 
534
extern int _mi_calc_bin_pack_key_length(MI_KEYDEF *keyinfo,uint nod_flag,
 
535
                                        uchar *key_pos,uchar *org_key,
 
536
                                        uchar *prev_key,
 
537
                                        uchar *key, MI_KEY_PARAM *s_temp);
 
538
void _mi_store_static_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
528
539
                           MI_KEY_PARAM *s_temp);
529
 
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,  unsigned char *key_pos,
 
540
void _mi_store_var_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
530
541
                             MI_KEY_PARAM *s_temp);
531
542
#ifdef NOT_USED
532
 
void _mi_store_pack_key(MI_KEYDEF *keyinfo,  unsigned char *key_pos,
 
543
void _mi_store_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
533
544
                         MI_KEY_PARAM *s_temp);
534
545
#endif
535
 
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,  unsigned char *key_pos,
 
546
void _mi_store_bin_pack_key(MI_KEYDEF *keyinfo,  uchar *key_pos,
536
547
                            MI_KEY_PARAM *s_temp);
537
548
 
538
 
extern int _mi_ck_delete(MI_INFO *info,uint32_t keynr,unsigned char *key,uint32_t key_length);
 
549
extern int _mi_ck_delete(MI_INFO *info,uint keynr,uchar *key,uint key_length);
539
550
extern int _mi_readinfo(MI_INFO *info,int lock_flag,int check_keybuffer);
540
 
extern int _mi_writeinfo(MI_INFO *info,uint32_t options);
 
551
extern int _mi_writeinfo(MI_INFO *info,uint options);
541
552
extern int _mi_test_if_changed(MI_INFO *info);
542
553
extern int _mi_mark_file_changed(MI_INFO *info);
543
554
extern int _mi_decrement_open_count(MI_INFO *info);
544
555
extern int _mi_check_index(MI_INFO *info,int inx);
545
 
extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,uint32_t key_len,
546
 
                      uint32_t nextflag,my_off_t pos);
 
556
extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,uint key_len,
 
557
                      uint nextflag,my_off_t pos);
547
558
extern int _mi_bin_search(struct st_myisam_info *info,MI_KEYDEF *keyinfo,
548
 
                          unsigned char *page,unsigned char *key,uint32_t key_len,uint32_t comp_flag,
549
 
                          unsigned char * *ret_pos,unsigned char *buff, bool *was_last_key);
550
 
extern int _mi_seq_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *page,
551
 
                          unsigned char *key,uint32_t key_len,uint32_t comp_flag,
552
 
                          unsigned char **ret_pos,unsigned char *buff, bool *was_last_key);
553
 
extern int _mi_prefix_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *page,
554
 
                          unsigned char *key,uint32_t key_len,uint32_t comp_flag,
555
 
                          unsigned char **ret_pos,unsigned char *buff, bool *was_last_key);
556
 
extern my_off_t _mi_kpos(uint32_t nod_flag,unsigned char *after_key);
557
 
extern void _mi_kpointer(MI_INFO *info,unsigned char *buff,my_off_t pos);
558
 
extern my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag,unsigned char *after_key);
559
 
extern my_off_t _mi_rec_pos(MYISAM_SHARE *info, unsigned char *ptr);
560
 
extern void _mi_dpointer(MI_INFO *info, unsigned char *buff,my_off_t pos);
561
 
extern uint32_t _mi_get_static_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
562
 
                               unsigned char *key);
563
 
extern uint32_t _mi_get_pack_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
564
 
                             unsigned char *key);
565
 
extern uint32_t _mi_get_binary_pack_key(MI_KEYDEF *keyinfo, uint32_t nod_flag,
566
 
                                    unsigned char **page_pos, unsigned char *key);
567
 
extern unsigned char *_mi_get_last_key(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *keypos,
568
 
                               unsigned char *lastkey,unsigned char *endpos,
569
 
                               uint32_t *return_key_length);
570
 
extern unsigned char *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, unsigned char *page,
571
 
                          unsigned char *key, unsigned char *keypos, uint32_t *return_key_length);
572
 
extern uint32_t _mi_keylength(MI_KEYDEF *keyinfo,unsigned char *key);
573
 
extern uint32_t _mi_keylength_part(MI_KEYDEF *keyinfo, register unsigned char *key,
 
559
                          uchar *page,uchar *key,uint key_len,uint comp_flag,
 
560
                          uchar * *ret_pos,uchar *buff, my_bool *was_last_key);
 
561
extern int _mi_seq_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *page,
 
562
                          uchar *key,uint key_len,uint comp_flag,
 
563
                          uchar **ret_pos,uchar *buff, my_bool *was_last_key);
 
564
extern int _mi_prefix_search(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *page,
 
565
                          uchar *key,uint key_len,uint comp_flag,
 
566
                          uchar **ret_pos,uchar *buff, my_bool *was_last_key);
 
567
extern my_off_t _mi_kpos(uint nod_flag,uchar *after_key);
 
568
extern void _mi_kpointer(MI_INFO *info,uchar *buff,my_off_t pos);
 
569
extern my_off_t _mi_dpos(MI_INFO *info, uint nod_flag,uchar *after_key);
 
570
extern my_off_t _mi_rec_pos(MYISAM_SHARE *info, uchar *ptr);
 
571
extern void _mi_dpointer(MI_INFO *info, uchar *buff,my_off_t pos);
 
572
extern uint _mi_get_static_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
 
573
                               uchar *key);
 
574
extern uint _mi_get_pack_key(MI_KEYDEF *keyinfo,uint nod_flag,uchar * *page,
 
575
                             uchar *key);
 
576
extern uint _mi_get_binary_pack_key(MI_KEYDEF *keyinfo, uint nod_flag,
 
577
                                    uchar **page_pos, uchar *key);
 
578
extern uchar *_mi_get_last_key(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *keypos,
 
579
                               uchar *lastkey,uchar *endpos,
 
580
                               uint *return_key_length);
 
581
extern uchar *_mi_get_key(MI_INFO *info, MI_KEYDEF *keyinfo, uchar *page,
 
582
                          uchar *key, uchar *keypos, uint *return_key_length);
 
583
extern uint _mi_keylength(MI_KEYDEF *keyinfo,uchar *key);
 
584
extern uint _mi_keylength_part(MI_KEYDEF *keyinfo, register uchar *key,
574
585
                               HA_KEYSEG *end);
575
 
extern unsigned char *_mi_move_key(MI_KEYDEF *keyinfo,unsigned char *to,unsigned char *from);
576
 
extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
577
 
                           uint32_t key_length,uint32_t nextflag,my_off_t pos);
 
586
extern uchar *_mi_move_key(MI_KEYDEF *keyinfo,uchar *to,uchar *from);
 
587
extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,uchar *key,
 
588
                           uint key_length,uint nextflag,my_off_t pos);
578
589
extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
579
590
extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
580
 
extern unsigned char *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
581
 
                                int level,unsigned char *buff,int return_buffer);
 
591
extern uchar *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
 
592
                                int level,uchar *buff,int return_buffer);
582
593
extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
583
 
                             int level, unsigned char *buff);
 
594
                             int level, uchar *buff);
584
595
extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos,
585
596
                      int level);
586
597
extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
587
 
extern uint32_t _mi_make_key(MI_INFO *info,uint32_t keynr,unsigned char *key,
588
 
                         const unsigned char *record,my_off_t filepos);
589
 
extern uint32_t _mi_pack_key(register MI_INFO *info, uint32_t keynr, unsigned char *key,
590
 
                         unsigned char *old, key_part_map keypart_map,
 
598
extern uint _mi_make_key(MI_INFO *info,uint keynr,uchar *key,
 
599
                         const uchar *record,my_off_t filepos);
 
600
extern uint _mi_pack_key(register MI_INFO *info, uint keynr, uchar *key,
 
601
                         uchar *old, key_part_map keypart_map,
591
602
                         HA_KEYSEG **last_used_keyseg);
592
 
extern int _mi_read_key_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
593
 
extern int _mi_read_cache(IO_CACHE *info,unsigned char *buff,my_off_t pos,
594
 
                          uint32_t length,int re_read_if_possibly);
595
 
extern uint64_t retrieve_auto_increment(MI_INFO *info,const unsigned char *record);
 
603
extern int _mi_read_key_record(MI_INFO *info,my_off_t filepos,uchar *buf);
 
604
extern int _mi_read_cache(IO_CACHE *info,uchar *buff,my_off_t pos,
 
605
                          uint length,int re_read_if_possibly);
 
606
extern ulonglong retrieve_auto_increment(MI_INFO *info,const uchar *record);
596
607
 
597
 
extern unsigned char *mi_alloc_rec_buff(MI_INFO *,ulong, unsigned char**);
 
608
extern uchar *mi_alloc_rec_buff(MI_INFO *,ulong, uchar**);
598
609
#define mi_get_rec_buff_ptr(info,buf)                              \
599
610
        ((((info)->s->options & HA_OPTION_PACK_RECORD) && (buf)) ? \
600
611
        (buf) - MI_REC_BUFF_OFFSET : (buf))
601
612
#define mi_get_rec_buff_len(info,buf)                              \
602
 
        (*((uint32_t *)(mi_get_rec_buff_ptr(info,buf))))
 
613
        (*((uint32 *)(mi_get_rec_buff_ptr(info,buf))))
603
614
 
604
 
extern ulong _mi_rec_unpack(MI_INFO *info,unsigned char *to,unsigned char *from,
 
615
extern ulong _mi_rec_unpack(MI_INFO *info,uchar *to,uchar *from,
605
616
                            ulong reclength);
606
 
extern bool _mi_rec_check(MI_INFO *info,const unsigned char *record, unsigned char *packpos,
607
 
                             ulong packed_length, bool with_checkum);
 
617
extern my_bool _mi_rec_check(MI_INFO *info,const uchar *record, uchar *packpos,
 
618
                             ulong packed_length, my_bool with_checkum);
608
619
extern int _mi_write_part_record(MI_INFO *info,my_off_t filepos,ulong length,
609
 
                                 my_off_t next_filepos,unsigned char **record,
 
620
                                 my_off_t next_filepos,uchar **record,
610
621
                                 ulong *reclength,int *flag);
611
 
extern void _mi_print_key(FILE *stream,HA_KEYSEG *keyseg,const unsigned char *key,
612
 
                          uint32_t length);
613
 
extern bool _mi_read_pack_info(MI_INFO *info,bool fix_keys);
614
 
extern int _mi_read_pack_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
615
 
extern int _mi_read_rnd_pack_record(MI_INFO*, unsigned char *,my_off_t, bool);
 
622
extern void _mi_print_key(FILE *stream,HA_KEYSEG *keyseg,const uchar *key,
 
623
                          uint length);
 
624
extern my_bool _mi_read_pack_info(MI_INFO *info,pbool fix_keys);
 
625
extern int _mi_read_pack_record(MI_INFO *info,my_off_t filepos,uchar *buf);
 
626
extern int _mi_read_rnd_pack_record(MI_INFO*, uchar *,my_off_t, my_bool);
616
627
extern int _mi_pack_rec_unpack(MI_INFO *info, MI_BIT_BUFF *bit_buff,
617
 
                               unsigned char *to, unsigned char *from, ulong reclength);
618
 
extern uint64_t mi_safe_mul(uint64_t a,uint64_t b);
 
628
                               uchar *to, uchar *from, ulong reclength);
 
629
extern ulonglong mi_safe_mul(ulonglong a,ulonglong b);
619
630
 
620
631
struct st_sort_info;
621
632
 
622
633
 
623
634
typedef struct st_mi_block_info {       /* Parameter to _mi_get_block_info */
624
 
  unsigned char header[MI_BLOCK_INFO_HEADER_LENGTH];
 
635
  uchar header[MI_BLOCK_INFO_HEADER_LENGTH];
625
636
  ulong rec_len;
626
637
  ulong data_len;
627
638
  ulong block_len;
629
640
  my_off_t filepos;
630
641
  my_off_t next_filepos;
631
642
  my_off_t prev_filepos;
632
 
  uint32_t second_read;
633
 
  uint32_t offset;
 
643
  uint second_read;
 
644
  uint offset;
634
645
} MI_BLOCK_INFO;
635
646
 
636
647
        /* bits in return from _mi_get_block_info */
660
671
#define SORT_BUFFER_INIT        (2048L*1024L-MALLOC_OVERHEAD)
661
672
#define MIN_SORT_BUFFER         (4096-MALLOC_OVERHEAD)
662
673
 
 
674
enum myisam_log_commands {
 
675
  MI_LOG_OPEN,MI_LOG_WRITE,MI_LOG_UPDATE,MI_LOG_DELETE,MI_LOG_CLOSE,MI_LOG_EXTRA,MI_LOG_LOCK,MI_LOG_DELETE_ALL
 
676
};
 
677
 
 
678
#define myisam_log(a,b,c,d) if (myisam_log_file >= 0) _myisam_log(a,b,c,d)
 
679
#define myisam_log_command(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_command(a,b,c,d,e)
 
680
#define myisam_log_record(a,b,c,d,e) if (myisam_log_file >= 0) _myisam_log_record(a,b,c,d,e)
 
681
 
663
682
#define fast_mi_writeinfo(INFO) if (!(INFO)->s->tot_locks) (void) _mi_writeinfo((INFO),0)
664
683
#define fast_mi_readinfo(INFO) ((INFO)->lock_type == F_UNLCK) && _mi_readinfo((INFO),F_RDLCK,1)
665
684
 
667
686
extern "C" {
668
687
#endif
669
688
 
670
 
extern uint32_t _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
671
 
extern uint32_t _mi_rec_pack(MI_INFO *info,unsigned char *to,const unsigned char *from);
672
 
extern uint32_t _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
673
 
                                    MI_BLOCK_INFO *info, unsigned char **rec_buff_p,
 
689
extern uint _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
 
690
extern uint _mi_rec_pack(MI_INFO *info,uchar *to,const uchar *from);
 
691
extern uint _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
 
692
                                    MI_BLOCK_INFO *info, uchar **rec_buff_p,
674
693
                                    File file, my_off_t filepos);
675
 
extern void _my_store_blob_length(unsigned char *pos,uint32_t pack_length,uint32_t length);
 
694
extern void _my_store_blob_length(uchar *pos,uint pack_length,uint length);
 
695
extern void _myisam_log(enum myisam_log_commands command,MI_INFO *info,
 
696
                       const uchar *buffert,uint length);
 
697
extern void _myisam_log_command(enum myisam_log_commands command,
 
698
                               MI_INFO *info, const uchar *buffert,
 
699
                               uint length, int result);
 
700
extern void _myisam_log_record(enum myisam_log_commands command,MI_INFO *info,
 
701
                              const uchar *record,my_off_t filepos,
 
702
                              int result);
676
703
extern void mi_report_error(int errcode, const char *file_name);
677
 
extern size_t mi_mmap_pread(MI_INFO *info, unsigned char *Buffer,
 
704
extern my_bool _mi_memmap_file(MI_INFO *info);
 
705
extern void _mi_unmap_file(MI_INFO *info);
 
706
extern uint save_pack_length(uint version, uchar *block_buff, ulong length);
 
707
extern uint read_pack_length(uint version, const uchar *buf, ulong *length);
 
708
extern uint calc_pack_length(uint version, ulong length);
 
709
extern size_t mi_mmap_pread(MI_INFO *info, uchar *Buffer,
678
710
                            size_t Count, my_off_t offset, myf MyFlags);
679
 
extern size_t mi_mmap_pwrite(MI_INFO *info, const unsigned char *Buffer,
 
711
extern size_t mi_mmap_pwrite(MI_INFO *info, const uchar *Buffer,
680
712
                             size_t Count, my_off_t offset, myf MyFlags);
681
 
extern size_t mi_nommap_pread(MI_INFO *info, unsigned char *Buffer,
 
713
extern size_t mi_nommap_pread(MI_INFO *info, uchar *Buffer,
682
714
                              size_t Count, my_off_t offset, myf MyFlags);
683
 
extern size_t mi_nommap_pwrite(MI_INFO *info, const unsigned char *Buffer,
 
715
extern size_t mi_nommap_pwrite(MI_INFO *info, const uchar *Buffer,
684
716
                               size_t Count, my_off_t offset, myf MyFlags);
685
717
 
686
 
uint32_t mi_state_info_write(File file, MI_STATE_INFO *state, uint32_t pWrite);
687
 
unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state);
688
 
uint32_t mi_state_info_read_dsk(File file, MI_STATE_INFO *state, bool pRead);
689
 
uint32_t mi_base_info_write(File file, MI_BASE_INFO *base);
690
 
unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base);
 
718
uint mi_state_info_write(File file, MI_STATE_INFO *state, uint pWrite);
 
719
uchar *mi_state_info_read(uchar *ptr, MI_STATE_INFO *state);
 
720
uint mi_state_info_read_dsk(File file, MI_STATE_INFO *state, my_bool pRead);
 
721
uint mi_base_info_write(File file, MI_BASE_INFO *base);
 
722
uchar *my_n_base_info_read(uchar *ptr, MI_BASE_INFO *base);
691
723
int mi_keyseg_write(File file, const HA_KEYSEG *keyseg);
692
 
unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg);
693
 
uint32_t mi_keydef_write(File file, MI_KEYDEF *keydef);
694
 
unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef);
695
 
uint32_t mi_uniquedef_write(File file, MI_UNIQUEDEF *keydef);
696
 
unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *keydef);
697
 
uint32_t mi_recinfo_write(File file, MI_COLUMNDEF *recinfo);
698
 
unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo);
 
724
uchar *mi_keyseg_read(uchar *ptr, HA_KEYSEG *keyseg);
 
725
uint mi_keydef_write(File file, MI_KEYDEF *keydef);
 
726
uchar *mi_keydef_read(uchar *ptr, MI_KEYDEF *keydef);
 
727
uint mi_uniquedef_write(File file, MI_UNIQUEDEF *keydef);
 
728
uchar *mi_uniquedef_read(uchar *ptr, MI_UNIQUEDEF *keydef);
 
729
uint mi_recinfo_write(File file, MI_COLUMNDEF *recinfo);
 
730
uchar *mi_recinfo_read(uchar *ptr, MI_COLUMNDEF *recinfo);
699
731
extern int mi_disable_indexes(MI_INFO *info);
700
732
extern int mi_enable_indexes(MI_INFO *info);
701
733
extern int mi_indexes_are_disabled(MI_INFO *info);
702
 
ulong _my_calc_total_blob_length(MI_INFO *info, const unsigned char *record);
703
 
ha_checksum mi_checksum(MI_INFO *info, const unsigned char *buf);
704
 
ha_checksum mi_static_checksum(MI_INFO *info, const unsigned char *buf);
705
 
bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, unsigned char *record,
 
734
ulong _my_calc_total_blob_length(MI_INFO *info, const uchar *record);
 
735
ha_checksum mi_checksum(MI_INFO *info, const uchar *buf);
 
736
ha_checksum mi_static_checksum(MI_INFO *info, const uchar *buf);
 
737
my_bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, uchar *record,
706
738
                     ha_checksum unique_hash, my_off_t pos);
707
 
ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const unsigned char *buf);
 
739
ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const uchar *buf);
708
740
int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
709
 
                           const unsigned char *record, my_off_t pos);
 
741
                           const uchar *record, my_off_t pos);
710
742
int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
711
 
                           const unsigned char *record, my_off_t pos);
712
 
int mi_unique_comp(MI_UNIQUEDEF *def, const unsigned char *a, const unsigned char *b,
713
 
                   bool null_are_equal);
 
743
                           const uchar *record, my_off_t pos);
 
744
int mi_unique_comp(MI_UNIQUEDEF *def, const uchar *a, const uchar *b,
 
745
                   my_bool null_are_equal);
714
746
void mi_get_status(void* param, int concurrent_insert);
715
747
void mi_update_status(void* param);
716
748
void mi_restore_status(void* param);
717
749
void mi_copy_status(void* to,void *from);
718
 
bool mi_check_status(void* param);
 
750
my_bool mi_check_status(void* param);
719
751
 
720
752
extern MI_INFO *test_if_reopen(char *filename);
721
 
bool check_table_is_closed(const char *name, const char *where);
 
753
my_bool check_table_is_closed(const char *name, const char *where);
722
754
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup);
723
755
int mi_open_keyfile(MYISAM_SHARE *share);
724
756
void mi_setup_functions(register MYISAM_SHARE *share);
725
 
bool mi_dynmap_file(MI_INFO *info, my_off_t size);
 
757
my_bool mi_dynmap_file(MI_INFO *info, my_off_t size);
726
758
void mi_remap_file(MI_INFO *info, my_off_t size);
727
759
 
728
 
int mi_check_index_cond(register MI_INFO *info, uint32_t keynr, unsigned char *record);
 
760
int mi_check_index_cond(register MI_INFO *info, uint keynr, uchar *record);
729
761
 
730
762
    /* Functions needed by mi_check */
731
763
volatile int *killed_ptr(MI_CHECK *param);
732
 
void mi_check_print_error(MI_CHECK *param, const char *fmt,...);
733
 
void mi_check_print_warning(MI_CHECK *param, const char *fmt,...);
734
 
void mi_check_print_info(MI_CHECK *param, const char *fmt,...);
 
764
void mi_check_print_error _VARARGS((MI_CHECK *param, const char *fmt,...));
 
765
void mi_check_print_warning _VARARGS((MI_CHECK *param, const char *fmt,...));
 
766
void mi_check_print_info _VARARGS((MI_CHECK *param, const char *fmt,...));
735
767
int flush_pending_blocks(MI_SORT_PARAM *param);
736
768
int thr_write_keys(MI_SORT_PARAM *sort_param);
737
769
pthread_handler_t thr_find_all_keys(void *arg);
738
770
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, File file);
739
771
 
740
772
int sort_write_record(MI_SORT_PARAM *sort_param);
741
 
int _create_index_by_sort(MI_SORT_PARAM *info,bool no_messages, uint32_t);
 
773
int _create_index_by_sort(MI_SORT_PARAM *info,my_bool no_messages, ulong);
742
774
 
743
775
extern void mi_set_index_cond_func(MI_INFO *info, index_cond_func_t func,
744
776
                                   void *func_arg);
745
777
/* Just for myisam legacy */
746
 
extern size_t my_pwrite(File Filedes,const unsigned char *Buffer,size_t Count,
 
778
extern size_t my_pwrite(File Filedes,const uchar *Buffer,size_t Count,
747
779
                      my_off_t offset,myf MyFlags);
748
 
extern size_t my_pread(File Filedes,unsigned char *Buffer,size_t Count,my_off_t offset,
 
780
extern size_t my_pread(File Filedes,uchar *Buffer,size_t Count,my_off_t offset,
749
781
                     myf MyFlags);
750
782
 
751
783
/* Needed for handler */
752
784
void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows);
753
 
void _mi_report_crashed(MI_INFO *file __attribute__((unused)),
754
 
                        const char *message __attribute__((unused)),
755
 
                        const char *sfile __attribute__((unused)),
756
 
                        uint32_t sline __attribute__((unused)));
757
 
 
758
785
#ifdef __cplusplus
759
786
}
760
787
#endif
761
788
 
762
 
 
763
 
#endif /* MYISAMDEF_H */
 
789
#endif