← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/myisamdef.h

Merged from lee.

Show diffs side-by-side

added added

removed removed

Lines of Context:
storage/myisam/myisamdef.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 is included by all internal myisam files */
17
17
 
18
 
#pragma once
19
 
 
20
 
#include <config.h>
 
18
#ifndef MYISAMDEF_H
 
19
#define MYISAMDEF_H
21
20
 
22
21
#include "myisam.h"                     /* Structs & some defines */
23
22
#include "myisampack.h"                 /* packing of keys */
24
 
#include <drizzled/tree.h>
25
 
#include <drizzled/internal/my_pthread.h>
26
 
#include <drizzled/thr_lock.h>
 
23
#include <mysys/my_tree.h>
 
24
#include <mysys/my_pthread.h>
 
25
#include <mysys/thr_lock.h>
27
26
#include <drizzled/common.h>
28
 
#include <drizzled/enum.h>
29
 
#include <drizzled/dynamic_array.h>
30
 
#include <drizzled/error_t.h>
31
 
 
32
 
#include <assert.h>
33
 
#include <fcntl.h>
34
 
#include <string.h>
35
 
#include <list>
36
 
 
37
 
#include <boost/thread/mutex.hpp>
38
27
 
39
28
#if defined(my_write)
40
29
#undef my_write                         /* undef map from my_nosys; We need test-if-disk full */
41
30
#endif
42
31
 
43
 
/* Typical key cash */
44
 
static const uint32_t KEY_CACHE_SIZE= 8*1024*1024;
45
 
 
46
 
/* Default size of a key cache block  */
47
 
static const uint32_t KEY_CACHE_BLOCK_SIZE= 1024;
48
 
 
49
32
typedef struct st_mi_status_info
50
33
{
51
 
  drizzled::ha_rows records;                    /* Rows in table */
52
 
  drizzled::ha_rows del;                                /* Removed rows */
53
 
  drizzled::internal::my_off_t empty;                   /* lost space in datafile */
54
 
  drizzled::internal::my_off_t key_empty;                       /* lost space in indexfile */
55
 
  drizzled::internal::my_off_t key_file_length;
56
 
  drizzled::internal::my_off_t data_file_length;
 
34
  ha_rows records;                      /* Rows in table */
 
35
  ha_rows del;                          /* Removed rows */
 
36
  my_off_t empty;                       /* lost space in datafile */
 
37
  my_off_t key_empty;                   /* lost space in indexfile */
 
38
  my_off_t key_file_length;
 
39
  my_off_t data_file_length;
57
40
  ha_checksum checksum;
58
41
} MI_STATUS_INFO;
59
42
 
77
60
  } header;
78
61
 
79
62
  MI_STATUS_INFO state;
80
 
  drizzled::ha_rows split;                      /* number of split blocks */
81
 
  drizzled::internal::my_off_t dellink;                 /* Link to next removed block */
 
63
  ha_rows split;                        /* number of split blocks */
 
64
  my_off_t dellink;                     /* Link to next removed block */
82
65
  uint64_t auto_increment;
83
66
  ulong process;                        /* process that updated table last */
84
67
  ulong unique;                         /* Unique number for this process */
85
68
  ulong update_count;                   /* Updated for each write lock */
86
69
  ulong status;
87
70
  ulong *rec_per_key_part;
88
 
  drizzled::internal::my_off_t *key_root;                       /* Start of key trees */
89
 
  drizzled::internal::my_off_t *key_del;                        /* delete links for trees */
90
 
  drizzled::internal::my_off_t rec_per_key_rows;                /* Rows when calculating rec_per_key */
 
71
  my_off_t *key_root;                   /* Start of key trees */
 
72
  my_off_t *key_del;                    /* delete links for trees */
 
73
  my_off_t rec_per_key_rows;            /* Rows when calculating rec_per_key */
91
74
 
92
75
  ulong sec_index_changed;              /* Updated when new sec_index */
93
76
  ulong sec_index_used;                 /* which extra index are in use */
121
104
 
122
105
typedef struct st_mi_base_info
123
106
{
124
 
  drizzled::internal::my_off_t keystart;                        /* Start of keys */
125
 
  drizzled::internal::my_off_t max_data_file_length;
126
 
  drizzled::internal::my_off_t max_key_file_length;
127
 
  drizzled::internal::my_off_t margin_key_file_length;
128
 
  drizzled::ha_rows records,reloc;              /* Create information */
 
107
  my_off_t keystart;                    /* Start of keys */
 
108
  my_off_t max_data_file_length;
 
109
  my_off_t max_key_file_length;
 
110
  my_off_t margin_key_file_length;
 
111
  ha_rows records,reloc;                /* Create information */
129
112
  ulong mean_row_length;                /* Create information */
130
113
  ulong reclength;                      /* length of unpacked record */
131
114
  ulong pack_reclength;                 /* Length of full packed rec. */
169
152
  unsigned char version;
170
153
} MI_PACK;
171
154
 
172
 
#define MAX_NONMAPPED_INSERTS 1000
 
155
#define MAX_NONMAPPED_INSERTS 1000      
173
156
 
174
157
typedef struct st_mi_isam_share {       /* Shared between opens */
175
158
  MI_STATE_INFO state;
178
161
  MI_KEYDEF  *keyinfo;                  /* Key definitions */
179
162
  MI_UNIQUEDEF *uniqueinfo;             /* unique definitions */
180
163
  HA_KEYSEG *keyparts;                  /* key part info */
181
 
  drizzled::MI_COLUMNDEF *rec;                  /* Pointer to field information */
 
164
  MI_COLUMNDEF *rec;                    /* Pointer to field information */
182
165
  MI_PACK    pack;                      /* Data about packed records */
183
166
  MI_BLOB    *blobs;                    /* Pointer to blobs */
184
 
  std::list<drizzled::Session *> *in_use;         /* List of threads using this table */
 
167
  LIST *in_use;                         /* List of threads using this table */
185
168
  char  *unique_file_name;              /* realpath() of index file */
186
169
  char  *data_file_name,                /* Resolved path names from symlinks */
187
170
        *index_file_name;
188
171
  unsigned char *file_map;                      /* mem-map of file if possible */
189
 
private:
190
 
  drizzled::KEY_CACHE key_cache;                        /* ref to the current key cache */
191
 
public:
192
 
  drizzled::KEY_CACHE *getKeyCache()
193
 
  {
194
 
    return &key_cache;
195
 
  }
196
 
 
197
 
  void setKeyCache();
198
 
 
 
172
  KEY_CACHE *key_cache;                 /* ref to the current key cache */
199
173
  MI_DECODE_TREE *decode_trees;
200
174
  uint16_t *decode_tables;
201
 
  int (*read_record)(struct st_myisam_info*, drizzled::internal::my_off_t, unsigned char*);
 
175
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
202
176
  int (*write_record)(struct st_myisam_info*, const unsigned char*);
203
 
  int (*update_record)(struct st_myisam_info*, drizzled::internal::my_off_t, const unsigned char*);
 
177
  int (*update_record)(struct st_myisam_info*, my_off_t, const unsigned char*);
204
178
  int (*delete_record)(struct st_myisam_info*);
205
 
  int (*read_rnd)(struct st_myisam_info*, unsigned char*, drizzled::internal::my_off_t, bool);
 
179
  int (*read_rnd)(struct st_myisam_info*, unsigned char*, my_off_t, bool);
206
180
  int (*compare_record)(struct st_myisam_info*, const unsigned char *);
207
181
  /* Function to use for a row checksum. */
208
182
  ha_checksum (*calc_checksum)(struct st_myisam_info*, const unsigned char *);
209
183
  int (*compare_unique)(struct st_myisam_info*, MI_UNIQUEDEF *,
210
 
                        const unsigned char *record, drizzled::internal::my_off_t pos);
211
 
  size_t (*file_read)(MI_INFO *, unsigned char *, size_t, drizzled::internal::my_off_t, drizzled::myf);
212
 
  size_t (*file_write)(MI_INFO *, const unsigned char *, size_t, drizzled::internal::my_off_t, drizzled::myf);
 
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);
 
187
  invalidator_by_filename invalidator;  /* query cache invalidator */
213
188
  ulong this_process;                   /* processid */
214
189
  ulong last_process;                   /* For table-change-check */
215
190
  ulong last_version;                   /* Version on start */
216
 
  uint64_t options;                     /* Options used */
 
191
  ulong options;                        /* Options used */
217
192
  ulong min_pack_length;                /* Theese are used by packed data */
218
193
  ulong max_pack_length;
219
194
  ulong state_diff_length;
220
195
  uint  rec_reflength;                  /* rec_reflength in use now */
221
196
  uint32_t  unique_name_length;
222
 
  int   kfile;                          /* Shared keyfile */
223
 
  int   data_file;                      /* Shared data file */
 
197
  File  kfile;                          /* Shared keyfile */
 
198
  File  data_file;                      /* Shared data file */
224
199
  int   mode;                           /* mode of file on open */
225
200
  uint  reopen;                         /* How many times reopened */
226
201
  uint  w_locks,r_locks,tot_locks;      /* Number of read/write locks */
227
202
  uint  blocksize;                      /* blocksize of keyfile */
228
 
  drizzled::myf write_flag;
229
 
  enum drizzled::data_file_type data_file_type;
 
203
  myf write_flag;
 
204
  enum data_file_type data_file_type;
230
205
  /* Below flag is needed to make log tables work with concurrent insert */
231
206
  bool is_log_table;
232
207
 
235
210
    not_flushed,
236
211
    temporary,delay_key_write,
237
212
    concurrent_insert;
238
 
  drizzled::internal::my_off_t mmaped_length;
 
213
  THR_LOCK lock;
 
214
  pthread_mutex_t intern_lock;          /* Locking for use with _locking */
 
215
  rw_lock_t *key_root_lock;
 
216
  my_off_t mmaped_length;
239
217
  uint32_t     nonmmaped_inserts;           /* counter of writing in non-mmaped
240
218
                                           area */
 
219
  rw_lock_t mmap_lock;
241
220
} MYISAM_SHARE;
242
221
 
243
222
 
259
238
  MI_BLOB     *blobs;                   /* Pointer to blobs */
260
239
  MI_BIT_BUFF  bit_buff;
261
240
  /* accumulate indexfile changes between write's */
262
 
  drizzled::TREE                *bulk_insert;
263
 
  drizzled::Session *in_use;                      /* Thread using this table          */
 
241
  TREE          *bulk_insert;
 
242
  LIST in_use;                          /* Thread using this table          */
264
243
  char *filename;                       /* parameter to open filename       */
265
244
  unsigned char *buff,                          /* Temp area for key                */
266
245
        *lastkey,*lastkey2;             /* Last used search key             */
270
249
        *int_maxpos;                    /*  -""-  */
271
250
  uint32_t  int_nod_flag;                       /*  -""-  */
272
251
  uint32_t int_keytree_version;         /*  -""-  */
273
 
  int (*read_record)(struct st_myisam_info*, drizzled::internal::my_off_t, unsigned char*);
 
252
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
 
253
  invalidator_by_filename invalidator;  /* query cache invalidator */
274
254
  ulong this_unique;                    /* uniq filenumber or thread */
275
255
  ulong last_unique;                    /* last unique number */
276
256
  ulong this_loop;                      /* counter for this open */
277
257
  ulong last_loop;                      /* last used counter */
278
 
  drizzled::internal::my_off_t lastpos,                 /* Last record position */
 
258
  my_off_t lastpos,                     /* Last record position */
279
259
        nextpos;                        /* Position to next record */
280
 
  drizzled::internal::my_off_t save_lastpos;
281
 
  drizzled::internal::my_off_t pos;                             /* Intern variable */
282
 
  drizzled::internal::my_off_t last_keypage;            /* Last key page read */
283
 
  drizzled::internal::my_off_t last_search_keypage;             /* Last keypage when searching */
284
 
  drizzled::internal::my_off_t dupp_key_pos;
 
260
  my_off_t save_lastpos;
 
261
  my_off_t pos;                         /* Intern variable */
 
262
  my_off_t last_keypage;                /* Last key page read */
 
263
  my_off_t last_search_keypage;         /* Last keypage when searching */
 
264
  my_off_t dupp_key_pos;
285
265
  ha_checksum checksum;                 /* Temp storage for row checksum */
286
266
  /* QQ: the folloing two xxx_length fields should be removed,
287
267
     as they are not compatible with parallel repair */
292
272
  int   lastinx;                        /* Last used index */
293
273
  uint  lastkey_length;                 /* Length of key in lastkey */
294
274
  uint  last_rkey_length;               /* Last length in mi_rkey() */
295
 
  enum drizzled::ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
 
275
  enum ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
296
276
  uint32_t  save_lastkey_length;
297
277
  uint32_t  pack_key_length;                /* For MYISAMMRG */
298
278
  uint16_t last_used_keyseg;              /* For MyISAMMRG */
302
282
  uint  data_changed;                   /* Somebody has changed data */
303
283
  uint  save_update;                    /* When using KEY_READ */
304
284
  int   save_lastinx;
305
 
  drizzled::internal::IO_CACHE rec_cache;                       /* When cacheing records */
 
285
  LIST  open_list;
 
286
  IO_CACHE rec_cache;                   /* When cacheing records */
306
287
  uint32_t  preload_buff_size;              /* When preloading indexes */
307
 
  drizzled::myf lock_wait;                      /* is 0 or MY_DONT_WAIT */
 
288
  myf lock_wait;                        /* is 0 or MY_DONT_WAIT */
308
289
  bool was_locked;                      /* Was locked in panic */
309
290
  bool append_insert_at_end;            /* Set if concurrent insert */
310
291
  bool quick_mode;
314
295
 
315
296
  index_cond_func_t index_cond_func;   /* Index condition function */
316
297
  void *index_cond_func_arg;           /* parameter for the func */
317
 
  drizzled::THR_LOCK_DATA lock;
 
298
  THR_LOCK_DATA lock;
318
299
  unsigned char  *rtree_recursion_state;        /* For RTREE */
319
300
  int     rtree_recursion_depth;
320
301
};
321
302
 
322
303
typedef struct st_buffpek {
323
 
  off_t file_pos;                    /* Where we are in the sort file */
 
304
  my_off_t file_pos;                    /* Where we are in the sort file */
324
305
  unsigned char *base,*key;                     /* Key pointers */
325
 
  drizzled::ha_rows count;                        /* Number of rows in table */
 
306
  ha_rows count;                        /* Number of rows in table */
326
307
  ulong mem_count;                      /* numbers of keys in memory */
327
308
  ulong max_keys;                       /* Max keys in buffert */
328
309
} BUFFPEK;
330
311
typedef struct st_mi_sort_param
331
312
{
332
313
  pthread_t  thr;
333
 
  drizzled::internal::IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
334
 
  drizzled::DYNAMIC_ARRAY buffpek;
 
314
  IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
 
315
  DYNAMIC_ARRAY buffpek;
335
316
  MI_BIT_BUFF   bit_buff;               /* For parallel repair of packrec. */
336
317
 
337
318
  /*
341
322
  uint64_t unique[MI_MAX_KEY_SEG+1];
342
323
  uint64_t notnull[MI_MAX_KEY_SEG+1];
343
324
 
344
 
  drizzled::internal::my_off_t pos,max_pos,filepos,start_recpos;
 
325
  my_off_t pos,max_pos,filepos,start_recpos;
345
326
  uint32_t key, key_length,real_key_length,sortbuff_size;
346
327
  uint32_t maxbuffers, keys, find_length, sort_keys_length;
347
328
  bool fix_datafile, master;
352
333
  unsigned char **sort_keys;
353
334
  unsigned char *rec_buff;
354
335
  void *wordlist, *wordptr;
355
 
  drizzled::memory::Root wordroot;
 
336
  MEM_ROOT wordroot;
356
337
  unsigned char *record;
 
338
  MY_TMPDIR *tmpdir;
357
339
  int (*key_cmp)(struct st_mi_sort_param *, const void *, const void *);
358
340
  int (*key_read)(struct st_mi_sort_param *,void *);
359
341
  int (*key_write)(struct st_mi_sort_param *, const void *);
360
342
  void (*lock_in_memory)(MI_CHECK *);
361
343
  int (*write_keys)(struct st_mi_sort_param *, register unsigned char **,
362
 
                     uint32_t , struct st_buffpek *, drizzled::internal::IO_CACHE *);
363
 
  unsigned int (*read_to_buffer)(drizzled::internal::IO_CACHE *,struct st_buffpek *, uint);
364
 
  int (*write_key)(struct st_mi_sort_param *, drizzled::internal::IO_CACHE *,unsigned char *,
 
344
                     uint32_t , struct st_buffpek *, IO_CACHE *);
 
345
  unsigned int (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
 
346
  int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,unsigned char *,
365
347
                       uint, uint);
366
348
} MI_SORT_PARAM;
367
349
 
473
455
#define MI_UNIQUE_HASH_TYPE     HA_KEYTYPE_ULONG_INT
474
456
#define mi_unique_store(A,B)    mi_int4store((A),(B))
475
457
 
476
 
extern boost::mutex THR_LOCK_myisam;
 
458
extern pthread_mutex_t THR_LOCK_myisam;
477
459
 
478
460
        /* Some extern variables */
479
461
 
480
 
extern std::list<MI_INFO *> myisam_open_list;
 
462
extern LIST *myisam_open_list;
481
463
extern unsigned char  myisam_file_magic[], myisam_pack_file_magic[];
482
464
extern uint32_t  myisam_read_vec[], myisam_readnext_vec[];
483
465
extern uint32_t myisam_quick_table_bits;
498
480
 
499
481
        /* Prototypes for intern functions */
500
482
 
501
 
extern int _mi_read_dynamic_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
 
483
extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
502
484
extern int _mi_write_dynamic_record(MI_INFO*, const unsigned char*);
503
 
extern int _mi_update_dynamic_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
 
485
extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const unsigned char*);
504
486
extern int _mi_delete_dynamic_record(MI_INFO *info);
505
487
extern int _mi_cmp_dynamic_record(MI_INFO *info,const unsigned char *record);
506
 
extern int _mi_read_rnd_dynamic_record(MI_INFO *, unsigned char *,drizzled::internal::my_off_t, bool);
 
488
extern int _mi_read_rnd_dynamic_record(MI_INFO *, unsigned char *,my_off_t, bool);
507
489
extern int _mi_write_blob_record(MI_INFO*, const unsigned char*);
508
 
extern int _mi_update_blob_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
509
 
extern int _mi_read_static_record(MI_INFO *info, drizzled::internal::my_off_t filepos,unsigned char *buf);
 
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);
510
492
extern int _mi_write_static_record(MI_INFO*, const unsigned char*);
511
 
extern int _mi_update_static_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
 
493
extern int _mi_update_static_record(MI_INFO*, my_off_t, const unsigned char*);
512
494
extern int _mi_delete_static_record(MI_INFO *info);
513
495
extern int _mi_cmp_static_record(MI_INFO *info,const unsigned char *record);
514
 
extern int _mi_read_rnd_static_record(MI_INFO*, unsigned char *,drizzled::internal::my_off_t, bool);
 
496
extern int _mi_read_rnd_static_record(MI_INFO*, unsigned char *,my_off_t, bool);
515
497
extern int _mi_ck_write(MI_INFO *info,uint32_t keynr,unsigned char *key,uint32_t length);
516
498
extern int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
517
499
                                   unsigned char *key, uint32_t key_length,
518
 
                                   drizzled::internal::my_off_t *root, uint32_t comp_flag);
519
 
extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key, drizzled::internal::my_off_t *root);
 
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);
520
502
extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
521
503
                      unsigned char *anc_buff,unsigned char *key_pos,unsigned char *key_buff,
522
504
                      unsigned char *father_buff, unsigned char *father_keypos,
523
 
                      drizzled::internal::my_off_t father_page, bool insert_last);
 
505
                      my_off_t father_page, bool insert_last);
524
506
extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
525
507
                          unsigned char *buff,unsigned char *key_buff, bool insert_last);
526
508
extern unsigned char *_mi_find_half_pos(uint32_t nod_flag,MI_KEYDEF *keyinfo,unsigned char *page,
554
536
                            MI_KEY_PARAM *s_temp);
555
537
 
556
538
extern int _mi_ck_delete(MI_INFO *info,uint32_t keynr,unsigned char *key,uint32_t key_length);
557
 
int _mi_readinfo(MI_INFO *info,int lock_flag,int check_keybuffer);
 
539
extern int _mi_readinfo(MI_INFO *info,int lock_flag,int check_keybuffer);
558
540
extern int _mi_writeinfo(MI_INFO *info,uint32_t options);
559
541
extern int _mi_test_if_changed(MI_INFO *info);
560
542
extern int _mi_mark_file_changed(MI_INFO *info);
561
543
extern int _mi_decrement_open_count(MI_INFO *info);
562
544
extern int _mi_check_index(MI_INFO *info,int inx);
563
545
extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,uint32_t key_len,
564
 
                      uint32_t nextflag,drizzled::internal::my_off_t pos);
 
546
                      uint32_t nextflag,my_off_t pos);
565
547
extern int _mi_bin_search(struct st_myisam_info *info,MI_KEYDEF *keyinfo,
566
548
                          unsigned char *page,unsigned char *key,uint32_t key_len,uint32_t comp_flag,
567
549
                          unsigned char * *ret_pos,unsigned char *buff, bool *was_last_key);
571
553
extern int _mi_prefix_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *page,
572
554
                          unsigned char *key,uint32_t key_len,uint32_t comp_flag,
573
555
                          unsigned char **ret_pos,unsigned char *buff, bool *was_last_key);
574
 
extern drizzled::internal::my_off_t _mi_kpos(uint32_t nod_flag,unsigned char *after_key);
575
 
extern void _mi_kpointer(MI_INFO *info,unsigned char *buff,drizzled::internal::my_off_t pos);
576
 
extern drizzled::internal::my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag,unsigned char *after_key);
577
 
extern drizzled::internal::my_off_t _mi_rec_pos(MYISAM_SHARE *info, unsigned char *ptr);
578
 
void _mi_dpointer(MI_INFO *info, unsigned char *buff,drizzled::internal::my_off_t pos);
 
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);
579
561
extern uint32_t _mi_get_static_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
580
562
                               unsigned char *key);
581
563
extern uint32_t _mi_get_pack_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
592
574
                               HA_KEYSEG *end);
593
575
extern unsigned char *_mi_move_key(MI_KEYDEF *keyinfo,unsigned char *to,unsigned char *from);
594
576
extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
595
 
                           uint32_t key_length,uint32_t nextflag,drizzled::internal::my_off_t pos);
596
 
extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos);
597
 
extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos);
598
 
extern unsigned char *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t page,
 
577
                           uint32_t key_length,uint32_t nextflag,my_off_t pos);
 
578
extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
 
579
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,
599
581
                                int level,unsigned char *buff,int return_buffer);
600
 
extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t page,
 
582
extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
601
583
                             int level, unsigned char *buff);
602
 
extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos,
 
584
extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos,
603
585
                      int level);
604
 
extern drizzled::internal::my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
 
586
extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
605
587
extern uint32_t _mi_make_key(MI_INFO *info,uint32_t keynr,unsigned char *key,
606
 
                         const unsigned char *record,drizzled::internal::my_off_t filepos);
 
588
                         const unsigned char *record,my_off_t filepos);
607
589
extern uint32_t _mi_pack_key(register MI_INFO *info, uint32_t keynr, unsigned char *key,
608
 
                         unsigned char *old, drizzled::key_part_map keypart_map,
 
590
                         unsigned char *old, key_part_map keypart_map,
609
591
                         HA_KEYSEG **last_used_keyseg);
610
 
extern int _mi_read_key_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
611
 
extern int _mi_read_cache(drizzled::internal::IO_CACHE *info,unsigned char *buff,drizzled::internal::my_off_t pos,
 
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,
612
594
                          uint32_t length,int re_read_if_possibly);
613
595
extern uint64_t retrieve_auto_increment(MI_INFO *info,const unsigned char *record);
614
596
 
615
 
unsigned char *mi_alloc_rec_buff(MI_INFO *info, size_t length, unsigned char **buf);
 
597
extern unsigned char *mi_alloc_rec_buff(MI_INFO *,ulong, unsigned char**);
616
598
#define mi_get_rec_buff_ptr(info,buf)                              \
617
599
        ((((info)->s->options & HA_OPTION_PACK_RECORD) && (buf)) ? \
618
600
        (buf) - MI_REC_BUFF_OFFSET : (buf))
623
605
                            ulong reclength);
624
606
extern bool _mi_rec_check(MI_INFO *info,const unsigned char *record, unsigned char *packpos,
625
607
                             ulong packed_length, bool with_checkum);
626
 
extern int _mi_write_part_record(MI_INFO *info,drizzled::internal::my_off_t filepos,ulong length,
627
 
                                 drizzled::internal::my_off_t next_filepos,unsigned char **record,
 
608
extern int _mi_write_part_record(MI_INFO *info,my_off_t filepos,ulong length,
 
609
                                 my_off_t next_filepos,unsigned char **record,
628
610
                                 ulong *reclength,int *flag);
629
611
extern void _mi_print_key(FILE *stream,HA_KEYSEG *keyseg,const unsigned char *key,
630
612
                          uint32_t length);
631
613
extern bool _mi_read_pack_info(MI_INFO *info,bool fix_keys);
632
 
extern int _mi_read_pack_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
633
 
extern int _mi_read_rnd_pack_record(MI_INFO*, unsigned char *,drizzled::internal::my_off_t, bool);
 
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);
634
616
extern int _mi_pack_rec_unpack(MI_INFO *info, MI_BIT_BUFF *bit_buff,
635
617
                               unsigned char *to, unsigned char *from, ulong reclength);
 
618
extern uint64_t mi_safe_mul(uint64_t a,uint64_t b);
636
619
 
637
620
struct st_sort_info;
638
621
 
643
626
  ulong data_len;
644
627
  ulong block_len;
645
628
  ulong blob_len;
646
 
  drizzled::internal::my_off_t filepos;
647
 
  drizzled::internal::my_off_t next_filepos;
648
 
  drizzled::internal::my_off_t prev_filepos;
 
629
  my_off_t filepos;
 
630
  my_off_t next_filepos;
 
631
  my_off_t prev_filepos;
649
632
  uint32_t second_read;
650
633
  uint32_t offset;
651
634
} MI_BLOCK_INFO;
662
645
#define NEED_MEM        ((uint) 10*4*(IO_SIZE+32)+32) /* Nead for recursion */
663
646
#define MAXERR                  20
664
647
#define BUFFERS_WHEN_SORTING    16              /* Alloc for sort-key-tree */
665
 
#define WRITE_COUNT             1000
 
648
#define WRITE_COUNT             MY_HOW_OFTEN_TO_WRITE
666
649
#define INDEX_TMP_EXT           ".TMM"
667
650
#define DATA_TMP_EXT            ".TMD"
668
651
 
680
663
#define fast_mi_writeinfo(INFO) if (!(INFO)->s->tot_locks) (void) _mi_writeinfo((INFO),0)
681
664
#define fast_mi_readinfo(INFO) ((INFO)->lock_type == F_UNLCK) && _mi_readinfo((INFO),F_RDLCK,1)
682
665
 
683
 
extern uint32_t _mi_get_block_info(MI_BLOCK_INFO *,int, drizzled::internal::my_off_t);
 
666
#ifdef  __cplusplus
 
667
extern "C" {
 
668
#endif
 
669
 
 
670
extern uint32_t _mi_get_block_info(MI_BLOCK_INFO *,File, my_off_t);
684
671
extern uint32_t _mi_rec_pack(MI_INFO *info,unsigned char *to,const unsigned char *from);
685
672
extern uint32_t _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
686
673
                                    MI_BLOCK_INFO *info, unsigned char **rec_buff_p,
687
 
                                    int file, drizzled::internal::my_off_t filepos);
 
674
                                    File file, my_off_t filepos);
688
675
extern void _my_store_blob_length(unsigned char *pos,uint32_t pack_length,uint32_t length);
689
676
extern void mi_report_error(int errcode, const char *file_name);
690
 
extern void mi_report_error(drizzled::error_t errcode, const char *file_name);
691
677
extern size_t mi_mmap_pread(MI_INFO *info, unsigned char *Buffer,
692
 
                            size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
 
678
                            size_t Count, my_off_t offset, myf MyFlags);
693
679
extern size_t mi_mmap_pwrite(MI_INFO *info, const unsigned char *Buffer,
694
 
                             size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
 
680
                             size_t Count, my_off_t offset, myf MyFlags);
695
681
extern size_t mi_nommap_pread(MI_INFO *info, unsigned char *Buffer,
696
 
                              size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
 
682
                              size_t Count, my_off_t offset, myf MyFlags);
697
683
extern size_t mi_nommap_pwrite(MI_INFO *info, const unsigned char *Buffer,
698
 
                               size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
 
684
                               size_t Count, my_off_t offset, myf MyFlags);
699
685
 
700
 
uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite);
701
 
uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead);
702
 
uint32_t mi_base_info_write(int file, MI_BASE_INFO *base);
703
 
int mi_keyseg_write(int file, const HA_KEYSEG *keyseg);
704
 
uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef);
705
 
uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *keydef);
706
 
uint32_t mi_recinfo_write(int file, drizzled::MI_COLUMNDEF *recinfo);
 
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);
 
691
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);
707
699
extern int mi_disable_indexes(MI_INFO *info);
708
700
extern int mi_enable_indexes(MI_INFO *info);
709
701
extern int mi_indexes_are_disabled(MI_INFO *info);
711
703
ha_checksum mi_checksum(MI_INFO *info, const unsigned char *buf);
712
704
ha_checksum mi_static_checksum(MI_INFO *info, const unsigned char *buf);
713
705
bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, unsigned char *record,
714
 
                     ha_checksum unique_hash, drizzled::internal::my_off_t pos);
 
706
                     ha_checksum unique_hash, my_off_t pos);
715
707
ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const unsigned char *buf);
716
708
int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
717
 
                           const unsigned char *record, drizzled::internal::my_off_t pos);
 
709
                           const unsigned char *record, my_off_t pos);
718
710
int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
719
 
                           const unsigned char *record, drizzled::internal::my_off_t pos);
 
711
                           const unsigned char *record, my_off_t pos);
720
712
int mi_unique_comp(MI_UNIQUEDEF *def, const unsigned char *a, const unsigned char *b,
721
713
                   bool null_are_equal);
 
714
void mi_get_status(void* param, int concurrent_insert);
 
715
void mi_update_status(void* param);
 
716
void mi_restore_status(void* param);
 
717
void mi_copy_status(void* to,void *from);
 
718
bool mi_check_status(void* param);
722
719
 
723
720
extern MI_INFO *test_if_reopen(char *filename);
724
721
bool check_table_is_closed(const char *name, const char *where);
725
 
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup);
 
722
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, File file_to_dup);
726
723
int mi_open_keyfile(MYISAM_SHARE *share);
727
724
void mi_setup_functions(register MYISAM_SHARE *share);
728
 
bool mi_dynmap_file(MI_INFO *info, drizzled::internal::my_off_t size);
729
 
void mi_remap_file(MI_INFO *info, drizzled::internal::my_off_t size);
 
725
bool mi_dynmap_file(MI_INFO *info, my_off_t size);
 
726
void mi_remap_file(MI_INFO *info, my_off_t size);
730
727
 
731
728
int mi_check_index_cond(register MI_INFO *info, uint32_t keynr, unsigned char *record);
732
729
 
737
734
void mi_check_print_info(MI_CHECK *param, const char *fmt,...);
738
735
int flush_pending_blocks(MI_SORT_PARAM *param);
739
736
int thr_write_keys(MI_SORT_PARAM *sort_param);
740
 
int flush_blocks(MI_CHECK *param, drizzled::KEY_CACHE *key_cache, int file);
 
737
pthread_handler_t thr_find_all_keys(void *arg);
 
738
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, File file);
741
739
 
742
740
int sort_write_record(MI_SORT_PARAM *sort_param);
743
 
int _create_index_by_sort(MI_SORT_PARAM *info,bool no_messages, size_t);
 
741
int _create_index_by_sort(MI_SORT_PARAM *info,bool no_messages, uint32_t);
744
742
 
745
743
extern void mi_set_index_cond_func(MI_INFO *info, index_cond_func_t func,
746
744
                                   void *func_arg);
747
745
/* Just for myisam legacy */
748
 
extern size_t my_pwrite(int Filedes,const unsigned char *Buffer,size_t Count,
749
 
                        drizzled::internal::my_off_t offset,drizzled::myf MyFlags);
750
 
extern size_t my_pread(int Filedes,unsigned char *Buffer,size_t Count,drizzled::internal::my_off_t offset,
751
 
                       drizzled::myf MyFlags);
 
746
extern size_t my_pwrite(File Filedes,const unsigned char *Buffer,size_t Count,
 
747
                      my_off_t offset,myf MyFlags);
 
748
extern size_t my_pread(File Filedes,unsigned char *Buffer,size_t Count,my_off_t offset,
 
749
                     myf MyFlags);
752
750
 
753
751
/* Needed for handler */
754
 
void mi_disable_non_unique_index(MI_INFO *info, drizzled::ha_rows rows);
755
 
void _mi_report_crashed(MI_INFO *file, const char *message, const char *sfile,
756
 
                        uint32_t sline);
757
 
 
758
 
 
759
 
#define DFLT_INIT_HITS  3
 
752
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
#ifdef __cplusplus
 
759
}
 
760
#endif
 
761
 
 
762
 
 
763
#endif /* MYISAMDEF_H */