← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/myisam.h

  • Committer: devananda
  • Date: 2009-07-01 17:38:47 UTC
  • mto: (1093.1.7 captain)
  • mto: This revision was merged to the branch mainline in revision 1095.
  • Revision ID: devananda.vdv@gmail.com-20090701173847-3n3mbtessg5ff35e
refactored function/benchmark into plugin/benchmark

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/myisam.h
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
15
15
 
16
16
/* This file should be included when using myisam_funktions */
17
17
 
18
 
#ifndef PLUGIN_MYISAM_MYISAM_H
19
 
#define PLUGIN_MYISAM_MYISAM_H
20
 
 
21
 
#include "drizzled/identifier/table.h"
 
18
#ifndef _myisam_h
 
19
#define _myisam_h
22
20
 
23
21
#include <drizzled/key_map.h>
24
22
 
 
23
#ifdef  __cplusplus
 
24
extern "C" {
 
25
#endif
 
26
 
25
27
#include <drizzled/base.h>
26
28
#ifndef _m_ctype_h
27
 
#include "drizzled/charset_info.h"
 
29
#include <mystrings/m_ctype.h>
28
30
#endif
29
31
#ifndef _keycache_h
30
32
#include "keycache.h"
31
33
#endif
32
34
#include <plugin/myisam/my_handler.h>
33
 
#include "drizzled/internal/iocache.h"
 
35
#include <mysys/iocache.h>
34
36
 
35
37
/*
36
38
  Limit max keys according to HA_MAX_POSSIBLE_KEY
124
126
 
125
127
typedef struct st_mi_isaminfo           /* Struct from h_info */
126
128
{
127
 
  drizzled::ha_rows records;                    /* Records in database */
128
 
  drizzled::ha_rows deleted;                    /* Deleted records in database */
129
 
  drizzled::internal::my_off_t recpos;                  /* Pos for last used record */
130
 
  drizzled::internal::my_off_t newrecpos;                       /* Pos if we write new record */
131
 
  drizzled::internal::my_off_t dupp_key_pos;            /* Position to record with dupp key */
132
 
  drizzled::internal::my_off_t data_file_length,                /* Length of data file */
 
129
  ha_rows records;                      /* Records in database */
 
130
  ha_rows deleted;                      /* Deleted records in database */
 
131
  my_off_t recpos;                      /* Pos for last used record */
 
132
  my_off_t newrecpos;                   /* Pos if we write new record */
 
133
  my_off_t dupp_key_pos;                /* Position to record with dupp key */
 
134
  my_off_t data_file_length,            /* Length of data file */
133
135
           max_data_file_length,
134
136
           index_file_length,
135
137
           max_index_file_length,
143
145
  uint  options;                        /* HA_OPTION_... used */
144
146
  int   errkey,                         /* With key was dupplicated on err */
145
147
        sortkey;                        /* clustered by this key */
146
 
  int   filenr;                         /* (uniq) filenr for datafile */
 
148
  File  filenr;                         /* (uniq) filenr for datafile */
147
149
  time_t create_time;                   /* When table was created */
148
150
  time_t check_time;
149
151
  time_t update_time;
156
158
typedef struct st_mi_create_info
157
159
{
158
160
  const char *index_file_name, *data_file_name; /* If using symlinks */
159
 
  drizzled::ha_rows max_rows;
160
 
  drizzled::ha_rows reloc_rows;
 
161
  ha_rows max_rows;
 
162
  ha_rows reloc_rows;
161
163
  uint64_t auto_increment;
162
164
  uint64_t data_file_length;
163
165
  uint64_t key_file_length;
164
166
  uint32_t old_options;
165
167
  uint8_t language;
166
168
  bool with_auto_increment;
167
 
 
168
 
  st_mi_create_info():
169
 
    index_file_name(0),
170
 
    data_file_name(0),
171
 
    max_rows(0),
172
 
    reloc_rows(0),
173
 
    auto_increment(0),
174
 
    data_file_length(0),
175
 
    key_file_length(0),
176
 
    old_options(0),
177
 
    language(0),
178
 
    with_auto_increment(0)
179
 
  { }
180
 
 
181
169
} MI_CREATE_INFO;
182
170
 
183
171
struct st_myisam_info;                  /* For referense */
244
232
  type, length, null_bit and null_pos
245
233
*/
246
234
 
247
 
namespace drizzled
248
 
{
249
 
 
250
235
typedef struct st_columndef             /* column information */
251
236
{
252
237
  int16_t  type;                                /* en_fieldtype */
258
243
#ifndef NOT_PACKED_DATABASES
259
244
  void (*unpack)(struct st_columndef *rec,struct st_mi_bit_buff *buff,
260
245
                 unsigned char *start,unsigned char *end);
261
 
  enum drizzled::en_fieldtype base_type;
 
246
  enum en_fieldtype base_type;
262
247
  uint32_t space_length_bits,pack_type;
263
248
  MI_DECODE_TREE *huff_tree;
264
249
#endif
265
250
} MI_COLUMNDEF;
266
251
 
267
 
}
268
 
 
269
252
 
270
253
extern char * myisam_log_filename;              /* Name of logfile */
271
254
extern uint32_t myisam_block_size;
272
255
extern uint32_t myisam_concurrent_insert;
 
256
extern bool myisam_flush,myisam_delay_key_write,myisam_single_user;
 
257
extern my_off_t myisam_max_temp_length;
273
258
extern uint32_t myisam_bulk_insert_tree_size; 
274
259
extern uint32_t data_pointer_size;
275
260
 
277
262
 
278
263
extern int mi_close(struct st_myisam_info *file);
279
264
extern int mi_delete(struct st_myisam_info *file,const unsigned char *buff);
280
 
extern struct st_myisam_info *mi_open(const drizzled::TableIdentifier &identifier,
281
 
                                      int mode,
 
265
extern struct st_myisam_info *mi_open(const char *name,int mode,
282
266
                                      uint32_t wait_if_locked);
283
 
extern int mi_panic(enum drizzled::ha_panic_function function);
 
267
extern int mi_panic(enum ha_panic_function function);
284
268
extern int mi_rfirst(struct st_myisam_info *file,unsigned char *buf,int inx);
285
269
extern int mi_rkey(MI_INFO *info, unsigned char *buf, int inx, const unsigned char *key,
286
 
                   drizzled::key_part_map keypart_map, enum drizzled::ha_rkey_function search_flag);
 
270
                   key_part_map keypart_map, enum ha_rkey_function search_flag);
287
271
extern int mi_rlast(struct st_myisam_info *file,unsigned char *buf,int inx);
288
272
extern int mi_rnext(struct st_myisam_info *file,unsigned char *buf,int inx);
289
273
extern int mi_rnext_same(struct st_myisam_info *info, unsigned char *buf);
290
274
extern int mi_rprev(struct st_myisam_info *file,unsigned char *buf,int inx);
291
 
extern int mi_rrnd(struct st_myisam_info *file,unsigned char *buf, drizzled::internal::my_off_t pos);
 
275
extern int mi_rrnd(struct st_myisam_info *file,unsigned char *buf, my_off_t pos);
292
276
extern int mi_scan_init(struct st_myisam_info *file);
293
277
extern int mi_scan(struct st_myisam_info *file,unsigned char *buf);
294
278
extern int mi_rsame(struct st_myisam_info *file,unsigned char *record,int inx);
 
279
extern int mi_rsame_with_pos(struct st_myisam_info *file,unsigned char *record,
 
280
                             int inx, my_off_t pos);
295
281
extern int mi_update(struct st_myisam_info *file,const unsigned char *old,
296
282
                     unsigned char *new_record);
297
283
extern int mi_write(struct st_myisam_info *file,unsigned char *buff);
298
 
extern drizzled::internal::my_off_t mi_position(struct st_myisam_info *file);
 
284
extern my_off_t mi_position(struct st_myisam_info *file);
299
285
extern int mi_status(struct st_myisam_info *info, MI_ISAMINFO *x, uint32_t flag);
300
286
extern int mi_lock_database(struct st_myisam_info *file,int lock_type);
301
287
extern int mi_create(const char *name,uint32_t keys,MI_KEYDEF *keydef,
302
 
                     uint32_t columns, drizzled::MI_COLUMNDEF *columndef,
 
288
                     uint32_t columns, MI_COLUMNDEF *columndef,
303
289
                     uint32_t uniques, MI_UNIQUEDEF *uniquedef,
304
290
                     MI_CREATE_INFO *create_info, uint32_t flags);
305
291
extern int mi_delete_table(const char *name);
306
292
extern int mi_rename(const char *from, const char *to);
307
293
extern int mi_extra(struct st_myisam_info *file,
308
 
                    enum drizzled::ha_extra_function function,
 
294
                    enum ha_extra_function function,
309
295
                    void *extra_arg);
310
296
extern int mi_reset(struct st_myisam_info *file);
311
 
extern drizzled::ha_rows mi_records_in_range(MI_INFO *info, int inx,
312
 
                                   drizzled::key_range *min_key, drizzled::key_range *max_key);
 
297
extern ha_rows mi_records_in_range(MI_INFO *info, int inx,
 
298
                                   key_range *min_key, key_range *max_key);
313
299
extern int mi_log(int activate_log);
 
300
extern int mi_is_changed(struct st_myisam_info *info);
314
301
extern int mi_delete_all_rows(struct st_myisam_info *info);
315
302
extern ulong _mi_calc_blob_length(uint32_t length , const unsigned char *pos);
316
303
extern uint32_t mi_get_pointer_length(uint64_t file_length, uint32_t def);
402
389
  uint64_t max_data_file_length;
403
390
  uint64_t keys_in_use;
404
391
  uint64_t max_record_length;
405
 
  drizzled::internal::my_off_t search_after_block;
406
 
  drizzled::internal::my_off_t new_file_pos,key_file_blocks;
407
 
  drizzled::internal::my_off_t keydata,totaldata,key_blocks,start_check_pos;
408
 
  drizzled::ha_rows total_records,total_deleted;
409
 
  drizzled::internal::ha_checksum record_checksum,glob_crc;
 
392
  my_off_t search_after_block;
 
393
  my_off_t new_file_pos,key_file_blocks;
 
394
  my_off_t keydata,totaldata,key_blocks,start_check_pos;
 
395
  ha_rows total_records,total_deleted;
 
396
  ha_checksum record_checksum,glob_crc;
410
397
  uint64_t use_buffers;
411
398
  size_t read_buffer_length, write_buffer_length,
412
399
         sort_buffer_length, sort_key_blocks;
418
405
  bool retry_repair, force_sort;
419
406
  char temp_filename[FN_REFLEN],*isam_file_name;
420
407
  int tmpfile_createflag;
421
 
  drizzled::myf myf_rw;
422
 
  drizzled::internal::IO_CACHE read_cache;
 
408
  myf myf_rw;
 
409
  IO_CACHE read_cache;
423
410
 
424
411
  /*
425
412
    The next two are used to collect statistics, see update_key_parts for
428
415
  uint64_t unique_count[MI_MAX_KEY_SEG+1];
429
416
  uint64_t notnull_count[MI_MAX_KEY_SEG+1];
430
417
 
431
 
  drizzled::internal::ha_checksum key_crc[HA_MAX_POSSIBLE_KEY];
 
418
  ha_checksum key_crc[HA_MAX_POSSIBLE_KEY];
432
419
  ulong rec_per_key_part[MI_MAX_KEY_SEG*HA_MAX_POSSIBLE_KEY];
433
420
  void *session;
434
421
  const char *db_name, *table_name;
438
425
 
439
426
typedef struct st_sort_info
440
427
{
441
 
  drizzled::internal::my_off_t filelength,dupp,buff_length;
442
 
  drizzled::ha_rows max_records;
 
428
  my_off_t filelength,dupp,buff_length;
 
429
  ha_rows max_records;
443
430
  uint32_t current_key, total_keys;
444
 
  drizzled::myf myf_rw;
445
 
  enum drizzled::data_file_type new_data_file_type;
 
431
  myf myf_rw;
 
432
  enum data_file_type new_data_file_type;
446
433
  MI_INFO *info;
447
434
  MI_CHECK *param;
448
435
  unsigned char *buff;
465
452
int mi_sort_index(MI_CHECK *param, register MI_INFO *info, char * name);
466
453
int mi_repair_by_sort(MI_CHECK *param, register MI_INFO *info,
467
454
                      const char * name, int rep_quick);
 
455
int mi_repair_parallel(MI_CHECK *param, register MI_INFO *info,
 
456
                      const char * name, int rep_quick);
468
457
int change_to_newfile(const char * filename, const char * old_ext,
469
458
                      const char * new_ext, uint32_t raid_chunks,
470
 
                      drizzled::myf myflags);
 
459
                      myf myflags);
471
460
void lock_memory(MI_CHECK *param);
472
461
void update_auto_increment_key(MI_CHECK *param, MI_INFO *info,
473
462
                               bool repair);
475
464
void update_key_parts(MI_KEYDEF *keyinfo, ulong *rec_per_key_part,
476
465
                      uint64_t *unique, uint64_t *notnull,
477
466
                      uint64_t records);
478
 
int filecopy(MI_CHECK *param, int to,int from,drizzled::internal::my_off_t start,
479
 
             drizzled::internal::my_off_t length, const char *type);
480
 
int movepoint(MI_INFO *info,unsigned char *record,drizzled::internal::my_off_t oldpos,
481
 
              drizzled::internal::my_off_t newpos, uint32_t prot_key);
 
467
int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
 
468
             my_off_t length, const char *type);
 
469
int movepoint(MI_INFO *info,unsigned char *record,my_off_t oldpos,
 
470
              my_off_t newpos, uint32_t prot_key);
482
471
int write_data_suffix(SORT_INFO *sort_info, bool fix_datafile);
483
472
int test_if_almost_full(MI_INFO *info);
484
 
bool mi_test_if_sort_rep(MI_INFO *info, drizzled::ha_rows rows, uint64_t key_map,
 
473
int recreate_table(MI_CHECK *param, MI_INFO **org_info, char *filename);
 
474
bool mi_test_if_sort_rep(MI_INFO *info, ha_rows rows, uint64_t key_map,
485
475
                            bool force);
486
476
 
487
 
int mi_init_bulk_insert(MI_INFO *info, uint32_t cache_size, drizzled::ha_rows rows);
 
477
int mi_init_bulk_insert(MI_INFO *info, uint32_t cache_size, ha_rows rows);
488
478
void mi_flush_bulk_insert(MI_INFO *info, uint32_t inx);
489
479
void mi_end_bulk_insert(MI_INFO *info);
 
480
int mi_assign_to_key_cache(MI_INFO *info, KEY_CACHE *key_cache); 
 
481
void mi_change_key_cache(KEY_CACHE *old_key_cache,
 
482
                         KEY_CACHE *new_key_cache);
490
483
int mi_preload(MI_INFO *info, uint64_t key_map, bool ignore_leaves);
491
484
 
492
 
#endif /* PLUGIN_MYISAM_MYISAM_H */
 
485
#ifdef  __cplusplus
 
486
}
 
487
#endif
 
488
#endif