← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/myisam_priv.h

  • Committer: Monty Taylor
  • Date: 2010-02-05 08:11:15 UTC
  • mfrom: (1283 build)
  • mto: (1273.13.43 fix_is)
  • mto: This revision was merged to the branch mainline in revision 1300.
  • Revision ID: mordred@inaugust.com-20100205081115-dr82nvrwv4lvw7sd
Merged trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/myisam_priv.h
35
35
#undef my_write                         /* undef map from my_nosys; We need test-if-disk full */
36
36
#endif
37
37
 
38
 
#ifdef  __cplusplus
39
 
extern "C" {
40
 
#endif
41
 
 
42
38
typedef struct st_mi_status_info
43
39
{
44
 
  ha_rows records;                      /* Rows in table */
45
 
  ha_rows del;                          /* Removed rows */
46
 
  my_off_t empty;                       /* lost space in datafile */
47
 
  my_off_t key_empty;                   /* lost space in indexfile */
48
 
  my_off_t key_file_length;
49
 
  my_off_t data_file_length;
50
 
  ha_checksum checksum;
 
40
  drizzled::ha_rows records;                    /* Rows in table */
 
41
  drizzled::ha_rows del;                                /* Removed rows */
 
42
  drizzled::internal::my_off_t empty;                   /* lost space in datafile */
 
43
  drizzled::internal::my_off_t key_empty;                       /* lost space in indexfile */
 
44
  drizzled::internal::my_off_t key_file_length;
 
45
  drizzled::internal::my_off_t data_file_length;
 
46
  drizzled::internal::ha_checksum checksum;
51
47
} MI_STATUS_INFO;
52
48
 
53
49
typedef struct st_mi_state_info
70
66
  } header;
71
67
 
72
68
  MI_STATUS_INFO state;
73
 
  ha_rows split;                        /* number of split blocks */
74
 
  my_off_t dellink;                     /* Link to next removed block */
 
69
  drizzled::ha_rows split;                      /* number of split blocks */
 
70
  drizzled::internal::my_off_t dellink;                 /* Link to next removed block */
75
71
  uint64_t auto_increment;
76
72
  ulong process;                        /* process that updated table last */
77
73
  ulong unique;                         /* Unique number for this process */
78
74
  ulong update_count;                   /* Updated for each write lock */
79
75
  ulong status;
80
76
  ulong *rec_per_key_part;
81
 
  my_off_t *key_root;                   /* Start of key trees */
82
 
  my_off_t *key_del;                    /* delete links for trees */
83
 
  my_off_t rec_per_key_rows;            /* Rows when calculating rec_per_key */
 
77
  drizzled::internal::my_off_t *key_root;                       /* Start of key trees */
 
78
  drizzled::internal::my_off_t *key_del;                        /* delete links for trees */
 
79
  drizzled::internal::my_off_t rec_per_key_rows;                /* Rows when calculating rec_per_key */
84
80
 
85
81
  ulong sec_index_changed;              /* Updated when new sec_index */
86
82
  ulong sec_index_used;                 /* which extra index are in use */
87
83
  uint64_t key_map;                     /* Which keys are in use */
88
 
  ha_checksum checksum;                 /* Table checksum */
 
84
  drizzled::internal::ha_checksum checksum;                 /* Table checksum */
89
85
  ulong version;                        /* timestamp of create */
90
86
  time_t create_time;                   /* Time when created database */
91
87
  time_t recover_time;                  /* Time for last recover */
114
110
 
115
111
typedef struct st_mi_base_info
116
112
{
117
 
  my_off_t keystart;                    /* Start of keys */
118
 
  my_off_t max_data_file_length;
119
 
  my_off_t max_key_file_length;
120
 
  my_off_t margin_key_file_length;
121
 
  ha_rows records,reloc;                /* Create information */
 
113
  drizzled::internal::my_off_t keystart;                        /* Start of keys */
 
114
  drizzled::internal::my_off_t max_data_file_length;
 
115
  drizzled::internal::my_off_t max_key_file_length;
 
116
  drizzled::internal::my_off_t margin_key_file_length;
 
117
  drizzled::ha_rows records,reloc;              /* Create information */
122
118
  ulong mean_row_length;                /* Create information */
123
119
  ulong reclength;                      /* length of unpacked record */
124
120
  ulong pack_reclength;                 /* Length of full packed rec. */
164
160
 
165
161
#define MAX_NONMAPPED_INSERTS 1000
166
162
 
167
 
class Session;
 
163
namespace drizzled { class Session; }
168
164
 
169
165
typedef struct st_mi_isam_share {       /* Shared between opens */
170
166
  MI_STATE_INFO state;
173
169
  MI_KEYDEF  *keyinfo;                  /* Key definitions */
174
170
  MI_UNIQUEDEF *uniqueinfo;             /* unique definitions */
175
171
  HA_KEYSEG *keyparts;                  /* key part info */
176
 
  MI_COLUMNDEF *rec;                    /* Pointer to field information */
 
172
  drizzled::MI_COLUMNDEF *rec;                  /* Pointer to field information */
177
173
  MI_PACK    pack;                      /* Data about packed records */
178
174
  MI_BLOB    *blobs;                    /* Pointer to blobs */
179
 
  std::list<Session *> *in_use;         /* List of threads using this table */
 
175
  std::list<drizzled::Session *> *in_use;         /* List of threads using this table */
180
176
  char  *unique_file_name;              /* realpath() of index file */
181
177
  char  *data_file_name,                /* Resolved path names from symlinks */
182
178
        *index_file_name;
183
179
  unsigned char *file_map;                      /* mem-map of file if possible */
184
 
  KEY_CACHE *key_cache;                 /* ref to the current key cache */
 
180
  drizzled::KEY_CACHE *key_cache;                       /* ref to the current key cache */
185
181
  MI_DECODE_TREE *decode_trees;
186
182
  uint16_t *decode_tables;
187
 
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
 
183
  int (*read_record)(struct st_myisam_info*, drizzled::internal::my_off_t, unsigned char*);
188
184
  int (*write_record)(struct st_myisam_info*, const unsigned char*);
189
 
  int (*update_record)(struct st_myisam_info*, my_off_t, const unsigned char*);
 
185
  int (*update_record)(struct st_myisam_info*, drizzled::internal::my_off_t, const unsigned char*);
190
186
  int (*delete_record)(struct st_myisam_info*);
191
 
  int (*read_rnd)(struct st_myisam_info*, unsigned char*, my_off_t, bool);
 
187
  int (*read_rnd)(struct st_myisam_info*, unsigned char*, drizzled::internal::my_off_t, bool);
192
188
  int (*compare_record)(struct st_myisam_info*, const unsigned char *);
193
189
  /* Function to use for a row checksum. */
194
 
  ha_checksum (*calc_checksum)(struct st_myisam_info*, const unsigned char *);
 
190
  drizzled::internal::ha_checksum (*calc_checksum)(struct st_myisam_info*, const unsigned char *);
195
191
  int (*compare_unique)(struct st_myisam_info*, MI_UNIQUEDEF *,
196
 
                        const unsigned char *record, my_off_t pos);
197
 
  size_t (*file_read)(MI_INFO *, unsigned char *, size_t, my_off_t, myf);
198
 
  size_t (*file_write)(MI_INFO *, const unsigned char *, size_t, my_off_t, myf);
 
192
                        const unsigned char *record, drizzled::internal::my_off_t pos);
 
193
  size_t (*file_read)(MI_INFO *, unsigned char *, size_t, drizzled::internal::my_off_t, drizzled::myf);
 
194
  size_t (*file_write)(MI_INFO *, const unsigned char *, size_t, drizzled::internal::my_off_t, drizzled::myf);
199
195
  ulong this_process;                   /* processid */
200
196
  ulong last_process;                   /* For table-change-check */
201
197
  ulong last_version;                   /* Version on start */
211
207
  uint  reopen;                         /* How many times reopened */
212
208
  uint  w_locks,r_locks,tot_locks;      /* Number of read/write locks */
213
209
  uint  blocksize;                      /* blocksize of keyfile */
214
 
  myf write_flag;
215
 
  enum data_file_type data_file_type;
 
210
  drizzled::myf write_flag;
 
211
  enum drizzled::data_file_type data_file_type;
216
212
  /* Below flag is needed to make log tables work with concurrent insert */
217
213
  bool is_log_table;
218
214
 
221
217
    not_flushed,
222
218
    temporary,delay_key_write,
223
219
    concurrent_insert;
224
 
  THR_LOCK lock;
 
220
  drizzled::THR_LOCK lock;
225
221
  pthread_mutex_t intern_lock;          /* Locking for use with _locking */
226
222
  pthread_rwlock_t *key_root_lock;
227
 
  my_off_t mmaped_length;
 
223
  drizzled::internal::my_off_t mmaped_length;
228
224
  uint32_t     nonmmaped_inserts;           /* counter of writing in non-mmaped
229
225
                                           area */
230
226
  pthread_rwlock_t mmap_lock;
249
245
  MI_BLOB     *blobs;                   /* Pointer to blobs */
250
246
  MI_BIT_BUFF  bit_buff;
251
247
  /* accumulate indexfile changes between write's */
252
 
  TREE          *bulk_insert;
253
 
  Session *in_use;                      /* Thread using this table          */
 
248
  drizzled::TREE                *bulk_insert;
 
249
  drizzled::Session *in_use;                      /* Thread using this table          */
254
250
  char *filename;                       /* parameter to open filename       */
255
251
  unsigned char *buff,                          /* Temp area for key                */
256
252
        *lastkey,*lastkey2;             /* Last used search key             */
260
256
        *int_maxpos;                    /*  -""-  */
261
257
  uint32_t  int_nod_flag;                       /*  -""-  */
262
258
  uint32_t int_keytree_version;         /*  -""-  */
263
 
  int (*read_record)(struct st_myisam_info*, my_off_t, unsigned char*);
 
259
  int (*read_record)(struct st_myisam_info*, drizzled::internal::my_off_t, unsigned char*);
264
260
  ulong this_unique;                    /* uniq filenumber or thread */
265
261
  ulong last_unique;                    /* last unique number */
266
262
  ulong this_loop;                      /* counter for this open */
267
263
  ulong last_loop;                      /* last used counter */
268
 
  my_off_t lastpos,                     /* Last record position */
 
264
  drizzled::internal::my_off_t lastpos,                 /* Last record position */
269
265
        nextpos;                        /* Position to next record */
270
 
  my_off_t save_lastpos;
271
 
  my_off_t pos;                         /* Intern variable */
272
 
  my_off_t last_keypage;                /* Last key page read */
273
 
  my_off_t last_search_keypage;         /* Last keypage when searching */
274
 
  my_off_t dupp_key_pos;
275
 
  ha_checksum checksum;                 /* Temp storage for row checksum */
 
266
  drizzled::internal::my_off_t save_lastpos;
 
267
  drizzled::internal::my_off_t pos;                             /* Intern variable */
 
268
  drizzled::internal::my_off_t last_keypage;            /* Last key page read */
 
269
  drizzled::internal::my_off_t last_search_keypage;             /* Last keypage when searching */
 
270
  drizzled::internal::my_off_t dupp_key_pos;
 
271
  drizzled::internal::ha_checksum checksum;                 /* Temp storage for row checksum */
276
272
  /* QQ: the folloing two xxx_length fields should be removed,
277
273
     as they are not compatible with parallel repair */
278
274
  ulong packed_length,blob_length;      /* Length of found, packed record */
282
278
  int   lastinx;                        /* Last used index */
283
279
  uint  lastkey_length;                 /* Length of key in lastkey */
284
280
  uint  last_rkey_length;               /* Last length in mi_rkey() */
285
 
  enum ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
 
281
  enum drizzled::ha_rkey_function last_key_func;  /* CONTAIN, OVERLAP, etc */
286
282
  uint32_t  save_lastkey_length;
287
283
  uint32_t  pack_key_length;                /* For MYISAMMRG */
288
284
  uint16_t last_used_keyseg;              /* For MyISAMMRG */
292
288
  uint  data_changed;                   /* Somebody has changed data */
293
289
  uint  save_update;                    /* When using KEY_READ */
294
290
  int   save_lastinx;
295
 
  IO_CACHE rec_cache;                   /* When cacheing records */
 
291
  drizzled::internal::IO_CACHE rec_cache;                       /* When cacheing records */
296
292
  uint32_t  preload_buff_size;              /* When preloading indexes */
297
 
  myf lock_wait;                        /* is 0 or MY_DONT_WAIT */
 
293
  drizzled::myf lock_wait;                      /* is 0 or MY_DONT_WAIT */
298
294
  bool was_locked;                      /* Was locked in panic */
299
295
  bool append_insert_at_end;            /* Set if concurrent insert */
300
296
  bool quick_mode;
304
300
 
305
301
  index_cond_func_t index_cond_func;   /* Index condition function */
306
302
  void *index_cond_func_arg;           /* parameter for the func */
307
 
  THR_LOCK_DATA lock;
 
303
  drizzled::THR_LOCK_DATA lock;
308
304
  unsigned char  *rtree_recursion_state;        /* For RTREE */
309
305
  int     rtree_recursion_depth;
310
306
};
312
308
typedef struct st_buffpek {
313
309
  off_t file_pos;                    /* Where we are in the sort file */
314
310
  unsigned char *base,*key;                     /* Key pointers */
315
 
  ha_rows count;                        /* Number of rows in table */
 
311
  drizzled::ha_rows count;                        /* Number of rows in table */
316
312
  ulong mem_count;                      /* numbers of keys in memory */
317
313
  ulong max_keys;                       /* Max keys in buffert */
318
314
} BUFFPEK;
320
316
typedef struct st_mi_sort_param
321
317
{
322
318
  pthread_t  thr;
323
 
  IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
324
 
  DYNAMIC_ARRAY buffpek;
 
319
  drizzled::internal::IO_CACHE read_cache, tempfile, tempfile_for_exceptions;
 
320
  drizzled::DYNAMIC_ARRAY buffpek;
325
321
  MI_BIT_BUFF   bit_buff;               /* For parallel repair of packrec. */
326
322
 
327
323
  /*
331
327
  uint64_t unique[MI_MAX_KEY_SEG+1];
332
328
  uint64_t notnull[MI_MAX_KEY_SEG+1];
333
329
 
334
 
  my_off_t pos,max_pos,filepos,start_recpos;
 
330
  drizzled::internal::my_off_t pos,max_pos,filepos,start_recpos;
335
331
  uint32_t key, key_length,real_key_length,sortbuff_size;
336
332
  uint32_t maxbuffers, keys, find_length, sort_keys_length;
337
333
  bool fix_datafile, master;
349
345
  int (*key_write)(struct st_mi_sort_param *, const void *);
350
346
  void (*lock_in_memory)(MI_CHECK *);
351
347
  int (*write_keys)(struct st_mi_sort_param *, register unsigned char **,
352
 
                     uint32_t , struct st_buffpek *, IO_CACHE *);
353
 
  unsigned int (*read_to_buffer)(IO_CACHE *,struct st_buffpek *, uint);
354
 
  int (*write_key)(struct st_mi_sort_param *, IO_CACHE *,unsigned char *,
 
348
                     uint32_t , struct st_buffpek *, drizzled::internal::IO_CACHE *);
 
349
  unsigned int (*read_to_buffer)(drizzled::internal::IO_CACHE *,struct st_buffpek *, uint);
 
350
  int (*write_key)(struct st_mi_sort_param *, drizzled::internal::IO_CACHE *,unsigned char *,
355
351
                       uint, uint);
356
352
} MI_SORT_PARAM;
357
353
 
488
484
 
489
485
        /* Prototypes for intern functions */
490
486
 
491
 
extern int _mi_read_dynamic_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
 
487
extern int _mi_read_dynamic_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
492
488
extern int _mi_write_dynamic_record(MI_INFO*, const unsigned char*);
493
 
extern int _mi_update_dynamic_record(MI_INFO*, my_off_t, const unsigned char*);
 
489
extern int _mi_update_dynamic_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
494
490
extern int _mi_delete_dynamic_record(MI_INFO *info);
495
491
extern int _mi_cmp_dynamic_record(MI_INFO *info,const unsigned char *record);
496
 
extern int _mi_read_rnd_dynamic_record(MI_INFO *, unsigned char *,my_off_t, bool);
 
492
extern int _mi_read_rnd_dynamic_record(MI_INFO *, unsigned char *,drizzled::internal::my_off_t, bool);
497
493
extern int _mi_write_blob_record(MI_INFO*, const unsigned char*);
498
 
extern int _mi_update_blob_record(MI_INFO*, my_off_t, const unsigned char*);
499
 
extern int _mi_read_static_record(MI_INFO *info, my_off_t filepos,unsigned char *buf);
 
494
extern int _mi_update_blob_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
 
495
extern int _mi_read_static_record(MI_INFO *info, drizzled::internal::my_off_t filepos,unsigned char *buf);
500
496
extern int _mi_write_static_record(MI_INFO*, const unsigned char*);
501
 
extern int _mi_update_static_record(MI_INFO*, my_off_t, const unsigned char*);
 
497
extern int _mi_update_static_record(MI_INFO*, drizzled::internal::my_off_t, const unsigned char*);
502
498
extern int _mi_delete_static_record(MI_INFO *info);
503
499
extern int _mi_cmp_static_record(MI_INFO *info,const unsigned char *record);
504
 
extern int _mi_read_rnd_static_record(MI_INFO*, unsigned char *,my_off_t, bool);
 
500
extern int _mi_read_rnd_static_record(MI_INFO*, unsigned char *,drizzled::internal::my_off_t, bool);
505
501
extern int _mi_ck_write(MI_INFO *info,uint32_t keynr,unsigned char *key,uint32_t length);
506
502
extern int _mi_ck_real_write_btree(MI_INFO *info, MI_KEYDEF *keyinfo,
507
503
                                   unsigned char *key, uint32_t key_length,
508
 
                                   my_off_t *root, uint32_t comp_flag);
509
 
extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key, my_off_t *root);
 
504
                                   drizzled::internal::my_off_t *root, uint32_t comp_flag);
 
505
extern int _mi_enlarge_root(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key, drizzled::internal::my_off_t *root);
510
506
extern int _mi_insert(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
511
507
                      unsigned char *anc_buff,unsigned char *key_pos,unsigned char *key_buff,
512
508
                      unsigned char *father_buff, unsigned char *father_keypos,
513
 
                      my_off_t father_page, bool insert_last);
 
509
                      drizzled::internal::my_off_t father_page, bool insert_last);
514
510
extern int _mi_split_page(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
515
511
                          unsigned char *buff,unsigned char *key_buff, bool insert_last);
516
512
extern unsigned char *_mi_find_half_pos(uint32_t nod_flag,MI_KEYDEF *keyinfo,unsigned char *page,
551
547
extern int _mi_decrement_open_count(MI_INFO *info);
552
548
extern int _mi_check_index(MI_INFO *info,int inx);
553
549
extern int _mi_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,uint32_t key_len,
554
 
                      uint32_t nextflag,my_off_t pos);
 
550
                      uint32_t nextflag,drizzled::internal::my_off_t pos);
555
551
extern int _mi_bin_search(struct st_myisam_info *info,MI_KEYDEF *keyinfo,
556
552
                          unsigned char *page,unsigned char *key,uint32_t key_len,uint32_t comp_flag,
557
553
                          unsigned char * *ret_pos,unsigned char *buff, bool *was_last_key);
561
557
extern int _mi_prefix_search(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *page,
562
558
                          unsigned char *key,uint32_t key_len,uint32_t comp_flag,
563
559
                          unsigned char **ret_pos,unsigned char *buff, bool *was_last_key);
564
 
extern my_off_t _mi_kpos(uint32_t nod_flag,unsigned char *after_key);
565
 
extern void _mi_kpointer(MI_INFO *info,unsigned char *buff,my_off_t pos);
566
 
extern my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag,unsigned char *after_key);
567
 
extern my_off_t _mi_rec_pos(MYISAM_SHARE *info, unsigned char *ptr);
568
 
void _mi_dpointer(MI_INFO *info, unsigned char *buff,my_off_t pos);
 
560
extern drizzled::internal::my_off_t _mi_kpos(uint32_t nod_flag,unsigned char *after_key);
 
561
extern void _mi_kpointer(MI_INFO *info,unsigned char *buff,drizzled::internal::my_off_t pos);
 
562
extern drizzled::internal::my_off_t _mi_dpos(MI_INFO *info, uint32_t nod_flag,unsigned char *after_key);
 
563
extern drizzled::internal::my_off_t _mi_rec_pos(MYISAM_SHARE *info, unsigned char *ptr);
 
564
void _mi_dpointer(MI_INFO *info, unsigned char *buff,drizzled::internal::my_off_t pos);
569
565
extern uint32_t _mi_get_static_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
570
566
                               unsigned char *key);
571
567
extern uint32_t _mi_get_pack_key(MI_KEYDEF *keyinfo,uint32_t nod_flag,unsigned char * *page,
582
578
                               HA_KEYSEG *end);
583
579
extern unsigned char *_mi_move_key(MI_KEYDEF *keyinfo,unsigned char *to,unsigned char *from);
584
580
extern int _mi_search_next(MI_INFO *info,MI_KEYDEF *keyinfo,unsigned char *key,
585
 
                           uint32_t key_length,uint32_t nextflag,my_off_t pos);
586
 
extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
587
 
extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos);
588
 
extern unsigned char *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
 
581
                           uint32_t key_length,uint32_t nextflag,drizzled::internal::my_off_t pos);
 
582
extern int _mi_search_first(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos);
 
583
extern int _mi_search_last(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos);
 
584
extern unsigned char *_mi_fetch_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t page,
589
585
                                int level,unsigned char *buff,int return_buffer);
590
 
extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t page,
 
586
extern int _mi_write_keypage(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t page,
591
587
                             int level, unsigned char *buff);
592
 
extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,my_off_t pos,
 
588
extern int _mi_dispose(MI_INFO *info,MI_KEYDEF *keyinfo,drizzled::internal::my_off_t pos,
593
589
                      int level);
594
 
extern my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
 
590
extern drizzled::internal::my_off_t _mi_new(MI_INFO *info,MI_KEYDEF *keyinfo,int level);
595
591
extern uint32_t _mi_make_key(MI_INFO *info,uint32_t keynr,unsigned char *key,
596
 
                         const unsigned char *record,my_off_t filepos);
 
592
                         const unsigned char *record,drizzled::internal::my_off_t filepos);
597
593
extern uint32_t _mi_pack_key(register MI_INFO *info, uint32_t keynr, unsigned char *key,
598
 
                         unsigned char *old, key_part_map keypart_map,
 
594
                         unsigned char *old, drizzled::key_part_map keypart_map,
599
595
                         HA_KEYSEG **last_used_keyseg);
600
 
extern int _mi_read_key_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
601
 
extern int _mi_read_cache(IO_CACHE *info,unsigned char *buff,my_off_t pos,
 
596
extern int _mi_read_key_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
 
597
extern int _mi_read_cache(drizzled::internal::IO_CACHE *info,unsigned char *buff,drizzled::internal::my_off_t pos,
602
598
                          uint32_t length,int re_read_if_possibly);
603
599
extern uint64_t retrieve_auto_increment(MI_INFO *info,const unsigned char *record);
604
600
 
613
609
                            ulong reclength);
614
610
extern bool _mi_rec_check(MI_INFO *info,const unsigned char *record, unsigned char *packpos,
615
611
                             ulong packed_length, bool with_checkum);
616
 
extern int _mi_write_part_record(MI_INFO *info,my_off_t filepos,ulong length,
617
 
                                 my_off_t next_filepos,unsigned char **record,
 
612
extern int _mi_write_part_record(MI_INFO *info,drizzled::internal::my_off_t filepos,ulong length,
 
613
                                 drizzled::internal::my_off_t next_filepos,unsigned char **record,
618
614
                                 ulong *reclength,int *flag);
619
615
extern void _mi_print_key(FILE *stream,HA_KEYSEG *keyseg,const unsigned char *key,
620
616
                          uint32_t length);
621
617
extern bool _mi_read_pack_info(MI_INFO *info,bool fix_keys);
622
 
extern int _mi_read_pack_record(MI_INFO *info,my_off_t filepos,unsigned char *buf);
623
 
extern int _mi_read_rnd_pack_record(MI_INFO*, unsigned char *,my_off_t, bool);
 
618
extern int _mi_read_pack_record(MI_INFO *info,drizzled::internal::my_off_t filepos,unsigned char *buf);
 
619
extern int _mi_read_rnd_pack_record(MI_INFO*, unsigned char *,drizzled::internal::my_off_t, bool);
624
620
extern int _mi_pack_rec_unpack(MI_INFO *info, MI_BIT_BUFF *bit_buff,
625
621
                               unsigned char *to, unsigned char *from, ulong reclength);
626
622
 
633
629
  ulong data_len;
634
630
  ulong block_len;
635
631
  ulong blob_len;
636
 
  my_off_t filepos;
637
 
  my_off_t next_filepos;
638
 
  my_off_t prev_filepos;
 
632
  drizzled::internal::my_off_t filepos;
 
633
  drizzled::internal::my_off_t next_filepos;
 
634
  drizzled::internal::my_off_t prev_filepos;
639
635
  uint32_t second_read;
640
636
  uint32_t offset;
641
637
} MI_BLOCK_INFO;
670
666
#define fast_mi_writeinfo(INFO) if (!(INFO)->s->tot_locks) (void) _mi_writeinfo((INFO),0)
671
667
#define fast_mi_readinfo(INFO) ((INFO)->lock_type == F_UNLCK) && _mi_readinfo((INFO),F_RDLCK,1)
672
668
 
673
 
extern uint32_t _mi_get_block_info(MI_BLOCK_INFO *,int, my_off_t);
 
669
extern uint32_t _mi_get_block_info(MI_BLOCK_INFO *,int, drizzled::internal::my_off_t);
674
670
extern uint32_t _mi_rec_pack(MI_INFO *info,unsigned char *to,const unsigned char *from);
675
671
extern uint32_t _mi_pack_get_block_info(MI_INFO *myisam, MI_BIT_BUFF *bit_buff,
676
672
                                    MI_BLOCK_INFO *info, unsigned char **rec_buff_p,
677
 
                                    int file, my_off_t filepos);
 
673
                                    int file, drizzled::internal::my_off_t filepos);
678
674
extern void _my_store_blob_length(unsigned char *pos,uint32_t pack_length,uint32_t length);
679
675
extern void mi_report_error(int errcode, const char *file_name);
680
676
extern size_t mi_mmap_pread(MI_INFO *info, unsigned char *Buffer,
681
 
                            size_t Count, my_off_t offset, myf MyFlags);
 
677
                            size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
682
678
extern size_t mi_mmap_pwrite(MI_INFO *info, const unsigned char *Buffer,
683
 
                             size_t Count, my_off_t offset, myf MyFlags);
 
679
                             size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
684
680
extern size_t mi_nommap_pread(MI_INFO *info, unsigned char *Buffer,
685
 
                              size_t Count, my_off_t offset, myf MyFlags);
 
681
                              size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
686
682
extern size_t mi_nommap_pwrite(MI_INFO *info, const unsigned char *Buffer,
687
 
                               size_t Count, my_off_t offset, myf MyFlags);
 
683
                               size_t Count, drizzled::internal::my_off_t offset, drizzled::myf MyFlags);
688
684
 
689
685
uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite);
690
686
uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead);
692
688
int mi_keyseg_write(int file, const HA_KEYSEG *keyseg);
693
689
uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef);
694
690
uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *keydef);
695
 
uint32_t mi_recinfo_write(int file, MI_COLUMNDEF *recinfo);
 
691
uint32_t mi_recinfo_write(int file, drizzled::MI_COLUMNDEF *recinfo);
696
692
extern int mi_disable_indexes(MI_INFO *info);
697
693
extern int mi_enable_indexes(MI_INFO *info);
698
694
extern int mi_indexes_are_disabled(MI_INFO *info);
699
695
ulong _my_calc_total_blob_length(MI_INFO *info, const unsigned char *record);
700
 
ha_checksum mi_checksum(MI_INFO *info, const unsigned char *buf);
701
 
ha_checksum mi_static_checksum(MI_INFO *info, const unsigned char *buf);
 
696
drizzled::internal::ha_checksum mi_checksum(MI_INFO *info, const unsigned char *buf);
 
697
drizzled::internal::ha_checksum mi_static_checksum(MI_INFO *info, const unsigned char *buf);
702
698
bool mi_check_unique(MI_INFO *info, MI_UNIQUEDEF *def, unsigned char *record,
703
 
                     ha_checksum unique_hash, my_off_t pos);
704
 
ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const unsigned char *buf);
 
699
                     drizzled::internal::ha_checksum unique_hash, drizzled::internal::my_off_t pos);
 
700
drizzled::internal::ha_checksum mi_unique_hash(MI_UNIQUEDEF *def, const unsigned char *buf);
705
701
int _mi_cmp_static_unique(MI_INFO *info, MI_UNIQUEDEF *def,
706
 
                           const unsigned char *record, my_off_t pos);
 
702
                           const unsigned char *record, drizzled::internal::my_off_t pos);
707
703
int _mi_cmp_dynamic_unique(MI_INFO *info, MI_UNIQUEDEF *def,
708
 
                           const unsigned char *record, my_off_t pos);
 
704
                           const unsigned char *record, drizzled::internal::my_off_t pos);
709
705
int mi_unique_comp(MI_UNIQUEDEF *def, const unsigned char *a, const unsigned char *b,
710
706
                   bool null_are_equal);
711
707
void mi_get_status(void* param, int concurrent_insert);
719
715
int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup);
720
716
int mi_open_keyfile(MYISAM_SHARE *share);
721
717
void mi_setup_functions(register MYISAM_SHARE *share);
722
 
bool mi_dynmap_file(MI_INFO *info, my_off_t size);
723
 
void mi_remap_file(MI_INFO *info, my_off_t size);
 
718
bool mi_dynmap_file(MI_INFO *info, drizzled::internal::my_off_t size);
 
719
void mi_remap_file(MI_INFO *info, drizzled::internal::my_off_t size);
724
720
 
725
721
int mi_check_index_cond(register MI_INFO *info, uint32_t keynr, unsigned char *record);
726
722
 
731
727
void mi_check_print_info(MI_CHECK *param, const char *fmt,...);
732
728
int flush_pending_blocks(MI_SORT_PARAM *param);
733
729
int thr_write_keys(MI_SORT_PARAM *sort_param);
734
 
pthread_handler_t thr_find_all_keys(void *arg);
735
 
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, int file);
 
730
/* needs extern "C" because we pass it to pthread_create */
 
731
extern "C" pthread_handler_t thr_find_all_keys(void *arg);
 
732
int flush_blocks(MI_CHECK *param, drizzled::KEY_CACHE *key_cache, int file);
736
733
 
737
734
int sort_write_record(MI_SORT_PARAM *sort_param);
738
735
int _create_index_by_sort(MI_SORT_PARAM *info,bool no_messages, size_t);
741
738
                                   void *func_arg);
742
739
/* Just for myisam legacy */
743
740
extern size_t my_pwrite(int Filedes,const unsigned char *Buffer,size_t Count,
744
 
                      my_off_t offset,myf MyFlags);
745
 
extern size_t my_pread(int Filedes,unsigned char *Buffer,size_t Count,my_off_t offset,
746
 
                     myf MyFlags);
 
741
                        drizzled::internal::my_off_t offset,drizzled::myf MyFlags);
 
742
extern size_t my_pread(int Filedes,unsigned char *Buffer,size_t Count,drizzled::internal::my_off_t offset,
 
743
                       drizzled::myf MyFlags);
747
744
 
748
745
/* Needed for handler */
749
 
void mi_disable_non_unique_index(MI_INFO *info, ha_rows rows);
 
746
void mi_disable_non_unique_index(MI_INFO *info, drizzled::ha_rows rows);
750
747
void _mi_report_crashed(MI_INFO *file, const char *message, const char *sfile,
751
748
                        uint32_t sline);
752
749
 
753
 
#ifdef __cplusplus
754
 
}
755
 
#endif
756
 
 
757
 
 
758
750
#endif /* PLUGIN_MYISAM_MYISAM_PRIV_H */