← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/myisam_priv.h

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

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