drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
mi_open.cc
1/* Copyright (C) 2000-2006 MySQL AB
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
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 */
15
16/* open a isam-database */
17
18#include "myisam_priv.h"
19
20#include <string.h>
21#include <algorithm>
22#include <memory>
23#include <boost/scoped_ptr.hpp>
24#include <boost/scoped_array.hpp>
25
26#include <drizzled/internal/m_string.h>
27#include <drizzled/util/test.h>
28#include <drizzled/charset.h>
29#include <drizzled/memory/multi_malloc.h>
30#include <drizzled/identifier.h>
31
32
33using namespace std;
34using namespace drizzled;
35
36static void setup_key_functions(MI_KEYDEF *keyinfo);
37static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef);
38static unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg);
39static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo);
40static uint64_t mi_safe_mul(uint64_t a, uint64_t b);
41static unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state);
42static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def);
43static unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base);
44
45#define disk_pos_assert(pos, end_pos) \
46if (pos > end_pos) \
47{ \
48 errno=HA_ERR_CRASHED; \
49 goto err; \
50}
51
52
53/******************************************************************************
54** Return the shared struct if the table is already open.
55** In MySQL the server will handle version issues.
56******************************************************************************/
57
58MI_INFO *test_if_reopen(char *filename)
59{
60 list<MI_INFO *>::iterator it= myisam_open_list.begin();
61 while (it != myisam_open_list.end())
62 {
63 MI_INFO *info= *it;
64 MYISAM_SHARE *share=info->s;
65 if (!strcmp(share->unique_file_name,filename) && share->last_version)
66 return info;
67 ++it;
68 }
69 return 0;
70}
71
72
73/******************************************************************************
74 open a MyISAM database.
75 See my_base.h for the handle_locking argument
76 if handle_locking and HA_OPEN_ABORT_IF_CRASHED then abort if the table
77 is marked crashed or if we are not using locking and the table doesn't
78 have an open count of 0.
79******************************************************************************/
80
81MI_INFO *mi_open(const drizzled::identifier::Table &identifier, int mode, uint32_t open_flags)
82{
83 int lock_error,kfile,open_mode,save_errno,have_rtree=0;
84 uint32_t i,j,len,errpos,head_length,base_pos,offset,info_length,keys,
85 key_parts,unique_key_parts,uniques;
86 char name_buff[FN_REFLEN], org_name[FN_REFLEN], index_name[FN_REFLEN],
87 data_name[FN_REFLEN];
88 char *rp_buff = NULL;
89 unsigned char *disk_cache= NULL;
90 unsigned char *disk_pos, *end_pos;
91 MI_INFO info= MI_INFO(), *m_info, *old_info;
92 boost::scoped_ptr<MYISAM_SHARE> share_buff_ap(new MYISAM_SHARE);
93 MYISAM_SHARE &share_buff= *share_buff_ap.get();
94 MYISAM_SHARE *share;
95 boost::scoped_array<ulong> rec_per_key_part_ap(new ulong[HA_MAX_POSSIBLE_KEY*MI_MAX_KEY_SEG]);
96 ulong *rec_per_key_part= rec_per_key_part_ap.get();
97 internal::my_off_t key_root[HA_MAX_POSSIBLE_KEY],key_del[MI_MAX_KEY_BLOCK_SIZE];
98 uint64_t max_key_file_length, max_data_file_length;
99
100 kfile= -1;
101 lock_error=1;
102 errpos=0;
103 head_length=sizeof(share_buff.state.header);
104
105 (void)internal::fn_format(org_name,
106 identifier.getPath().c_str(),
107 "",
108 MI_NAME_IEXT,
109 MY_UNPACK_FILENAME);
110
111 rp_buff = realpath(org_name,NULL);
112 if (!rp_buff)
113 {
114 internal::my_load_path(name_buff,org_name, NULL);
115 } else {
116 if (strlen(rp_buff)>=FN_REFLEN) rp_buff[FN_REFLEN-1]= '\0';
117 strcpy(name_buff,rp_buff);
118 free(rp_buff);
119 }
120
121 THR_LOCK_myisam.lock();
122 if (!(old_info=test_if_reopen(name_buff)))
123 {
124 share= &share_buff;
125 memset(&share_buff, 0, sizeof(share_buff));
126 share_buff.state.rec_per_key_part=rec_per_key_part;
127 share_buff.state.key_root=key_root;
128 share_buff.state.key_del=key_del;
129
130 if ((kfile=internal::my_open(name_buff,(open_mode=O_RDWR),MYF(0))) < 0)
131 {
132 if ((errno != EROFS && errno != EACCES) ||
133 mode != O_RDONLY ||
134 (kfile=internal::my_open(name_buff,(open_mode=O_RDONLY),MYF(0))) < 0)
135 goto err;
136 }
137 share->mode=open_mode;
138 errpos=1;
139 if (internal::my_read(kfile, share->state.header.file_version, head_length,
140 MYF(MY_NABP)))
141 {
142 errno= HA_ERR_NOT_A_TABLE;
143 goto err;
144 }
145 if (memcmp(share->state.header.file_version, myisam_file_magic, 4))
146 {
147 errno=HA_ERR_NOT_A_TABLE;
148 goto err;
149 }
150 share->options= mi_uint2korr(share->state.header.options);
151 static const uint64_t OLD_FILE_OPTIONS= HA_OPTION_PACK_RECORD |
152 HA_OPTION_PACK_KEYS |
153 HA_OPTION_COMPRESS_RECORD | HA_OPTION_READ_ONLY_DATA |
154 HA_OPTION_TEMP_COMPRESS_RECORD |
155 HA_OPTION_TMP_TABLE;
156 if (share->options & ~OLD_FILE_OPTIONS)
157 {
158 errno=HA_ERR_OLD_FILE;
159 goto err;
160 }
161
162 /* Don't call realpath() if the name can't be a link */
163 ssize_t sym_link_size= readlink(org_name,index_name,FN_REFLEN-1);
164 if (sym_link_size >= 0 )
165 index_name[sym_link_size]= '\0';
166 if (!strcmp(name_buff, org_name) || sym_link_size == -1)
167 (void) strcpy(index_name, org_name);
168 *strrchr(org_name, '.')= '\0';
169 (void) internal::fn_format(data_name,org_name,"",MI_NAME_DEXT,
170 MY_APPEND_EXT|MY_UNPACK_FILENAME);
171
172 info_length=mi_uint2korr(share->state.header.header_length);
173 base_pos=mi_uint2korr(share->state.header.base_pos);
174 if (!(disk_cache= (unsigned char*) malloc(info_length+128)))
175 {
176 errno=ENOMEM;
177 goto err;
178 }
179 end_pos=disk_cache+info_length;
180 errpos=2;
181
182 lseek(kfile,0,SEEK_SET);
183 errpos=3;
184 if (internal::my_read(kfile,disk_cache,info_length,MYF(MY_NABP)))
185 {
186 errno=HA_ERR_CRASHED;
187 goto err;
188 }
189 len=mi_uint2korr(share->state.header.state_info_length);
190 keys= (uint) share->state.header.keys;
191 uniques= (uint) share->state.header.uniques;
192 key_parts= mi_uint2korr(share->state.header.key_parts);
193 unique_key_parts= mi_uint2korr(share->state.header.unique_key_parts);
194 share->state_diff_length=len-MI_STATE_INFO_SIZE;
195
196 mi_state_info_read(disk_cache, &share->state);
197 len= mi_uint2korr(share->state.header.base_info_length);
198 disk_pos= my_n_base_info_read(disk_cache + base_pos, &share->base);
199 share->state.state_length=base_pos;
200
201 if (share->state.changed & STATE_CRASHED)
202 {
203 errno=((share->state.changed & STATE_CRASHED_ON_REPAIR) ?
204 HA_ERR_CRASHED_ON_REPAIR : HA_ERR_CRASHED_ON_USAGE);
205 goto err;
206 }
207
208 /* sanity check */
209 if (share->base.keystart > 65535 || share->base.rec_reflength > 8)
210 {
211 errno=HA_ERR_CRASHED;
212 goto err;
213 }
214
215 if (share->base.max_key_length > MI_MAX_KEY_BUFF || keys > MI_MAX_KEY ||
216 key_parts > MI_MAX_KEY * MI_MAX_KEY_SEG)
217 {
218 errno=HA_ERR_UNSUPPORTED;
219 goto err;
220 }
221
222 /* Correct max_file_length based on length of sizeof(off_t) */
223 max_data_file_length=
224 (share->options & (HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ?
225 (((uint64_t) 1 << (share->base.rec_reflength*8))-1) :
226 (mi_safe_mul(share->base.pack_reclength,
227 (uint64_t) 1 << (share->base.rec_reflength*8))-1);
228 max_key_file_length=
229 mi_safe_mul(MI_MIN_KEY_BLOCK_LENGTH,
230 ((uint64_t) 1 << (share->base.key_reflength*8))-1);
231#if SIZEOF_OFF_T == 4
232 set_if_smaller(max_data_file_length, INT32_MAX);
233 set_if_smaller(max_key_file_length, INT32_MAX);
234#endif
235 if (share->base.raid_type)
236 {
237 errno=HA_ERR_UNSUPPORTED;
238 goto err;
239 }
240 share->base.max_data_file_length=(internal::my_off_t) max_data_file_length;
241 share->base.max_key_file_length=(internal::my_off_t) max_key_file_length;
242
243 if (share->options & HA_OPTION_COMPRESS_RECORD)
244 share->base.max_key_length+=2; /* For safety */
245
246 /* Add space for node pointer */
247 share->base.max_key_length+= share->base.key_reflength;
248
249 if (!drizzled::memory::multi_malloc(false,
250 &share,sizeof(*share),
251 &share->state.rec_per_key_part,sizeof(long)*key_parts,
252 &share->keyinfo,keys*sizeof(MI_KEYDEF),
253 &share->uniqueinfo,uniques*sizeof(MI_UNIQUEDEF),
254 &share->keyparts,
255 (key_parts+unique_key_parts+keys+uniques) * sizeof(HA_KEYSEG),
256 &share->rec, (share->base.fields+1)*sizeof(MI_COLUMNDEF),
257 &share->blobs,sizeof(MI_BLOB)*share->base.blobs,
258 &share->unique_file_name,strlen(name_buff)+1,
259 &share->index_file_name,strlen(index_name)+1,
260 &share->data_file_name,strlen(data_name)+1,
261 &share->state.key_root,keys*sizeof(uint64_t),
262 &share->state.key_del,
263 (share->state.header.max_block_size_index*sizeof(uint64_t)),
264 NULL))
265 goto err;
266 errpos=4;
267 *share=share_buff;
268 memcpy(share->state.rec_per_key_part, rec_per_key_part,
269 sizeof(long)*key_parts);
270 memcpy(share->state.key_root, key_root,
271 sizeof(internal::my_off_t)*keys);
272 memcpy(share->state.key_del, key_del,
273 sizeof(internal::my_off_t) * share->state.header.max_block_size_index);
274 strcpy(share->unique_file_name, name_buff);
275 share->unique_name_length= strlen(name_buff);
276 strcpy(share->index_file_name, index_name);
277 strcpy(share->data_file_name, data_name);
278
279 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
280 {
281 HA_KEYSEG *pos=share->keyparts;
282 for (i=0 ; i < keys ; i++)
283 {
284 share->keyinfo[i].share= share;
285 disk_pos=mi_keydef_read(disk_pos, &share->keyinfo[i]);
286 disk_pos_assert(disk_pos + share->keyinfo[i].keysegs * HA_KEYSEG_SIZE,
287 end_pos);
288 set_if_smaller(share->blocksize,(uint)share->keyinfo[i].block_length);
289 share->keyinfo[i].seg=pos;
290 for (j=0 ; j < share->keyinfo[i].keysegs; j++,pos++)
291 {
292 disk_pos=mi_keyseg_read(disk_pos, pos);
293 if (pos->flag & HA_BLOB_PART &&
294 ! (share->options & (HA_OPTION_COMPRESS_RECORD |
295 HA_OPTION_PACK_RECORD)))
296 {
297 errno= HA_ERR_CRASHED;
298 goto err;
299 }
300 if (pos->type == HA_KEYTYPE_TEXT ||
301 pos->type == HA_KEYTYPE_VARTEXT1 ||
302 pos->type == HA_KEYTYPE_VARTEXT2)
303 {
304 if (!pos->language)
305 pos->charset=default_charset_info;
306 else if (!(pos->charset= get_charset(pos->language)))
307 {
308 errno=HA_ERR_UNKNOWN_CHARSET;
309 goto err;
310 }
311 }
312 else if (pos->type == HA_KEYTYPE_BINARY)
313 pos->charset= &my_charset_bin;
314 }
315 setup_key_functions(share->keyinfo+i);
316 share->keyinfo[i].end=pos;
317 pos->type=HA_KEYTYPE_END; /* End */
318 pos->length=share->base.rec_reflength;
319 pos->null_bit=0;
320 pos->flag=0; /* For purify */
321 pos++;
322 }
323 for (i=0 ; i < uniques ; i++)
324 {
325 disk_pos=mi_uniquedef_read(disk_pos, &share->uniqueinfo[i]);
326 disk_pos_assert(disk_pos + share->uniqueinfo[i].keysegs *
327 HA_KEYSEG_SIZE, end_pos);
328 share->uniqueinfo[i].seg=pos;
329 for (j=0 ; j < share->uniqueinfo[i].keysegs; j++,pos++)
330 {
331 disk_pos=mi_keyseg_read(disk_pos, pos);
332 if (pos->type == HA_KEYTYPE_TEXT ||
333 pos->type == HA_KEYTYPE_VARTEXT1 ||
334 pos->type == HA_KEYTYPE_VARTEXT2)
335 {
336 if (!pos->language)
337 pos->charset=default_charset_info;
338 else if (!(pos->charset= get_charset(pos->language)))
339 {
340 errno=HA_ERR_UNKNOWN_CHARSET;
341 goto err;
342 }
343 }
344 }
345 share->uniqueinfo[i].end=pos;
346 pos->type=HA_KEYTYPE_END; /* End */
347 pos->null_bit=0;
348 pos->flag=0;
349 pos++;
350 }
351 }
352
353 disk_pos_assert(disk_pos + share->base.fields *MI_COLUMNDEF_SIZE, end_pos);
354 for (i=j=offset=0 ; i < share->base.fields ; i++)
355 {
356 disk_pos=mi_recinfo_read(disk_pos,&share->rec[i]);
357 share->rec[i].pack_type=0;
358 share->rec[i].huff_tree=0;
359 share->rec[i].offset=offset;
360 if (share->rec[i].type == (int) FIELD_BLOB)
361 {
362 share->blobs[j].pack_length=
363 share->rec[i].length-portable_sizeof_char_ptr;
364 share->blobs[j].offset=offset;
365 j++;
366 }
367 offset+=share->rec[i].length;
368 }
369 share->rec[i].type=(int) FIELD_LAST; /* End marker */
370 if (offset > share->base.reclength)
371 {
372 errno= HA_ERR_CRASHED;
373 goto err;
374 }
375
376 if (! lock_error)
377 {
378 lock_error=1; /* Database unlocked */
379 }
380
381 if (mi_open_datafile(&info, share, -1))
382 goto err;
383 errpos=5;
384
385 share->kfile=kfile;
386 share->this_process=(ulong) getpid();
387 share->last_process= share->state.process;
388 share->base.key_parts=key_parts;
389 share->base.all_key_parts=key_parts+unique_key_parts;
390 if (!(share->last_version=share->state.version))
391 share->last_version=1; /* Safety */
392 share->rec_reflength=share->base.rec_reflength; /* May be changed */
393 share->base.margin_key_file_length=(share->base.max_key_file_length -
394 (keys ? MI_INDEX_BLOCK_MARGIN *
395 share->blocksize * keys : 0));
396 share->blocksize=min((uint32_t)IO_SIZE,myisam_block_size);
397 share->data_file_type=STATIC_RECORD;
398 if (share->options & HA_OPTION_PACK_RECORD)
399 share->data_file_type = DYNAMIC_RECORD;
400 free(disk_cache);
401 disk_cache= NULL;
402 mi_setup_functions(share);
403 share->is_log_table= false;
404 if (myisam_concurrent_insert)
405 {
406 share->concurrent_insert=
407 ((share->options & (HA_OPTION_READ_ONLY_DATA | HA_OPTION_TMP_TABLE |
408 HA_OPTION_COMPRESS_RECORD |
409 HA_OPTION_TEMP_COMPRESS_RECORD)) ||
410 (open_flags & HA_OPEN_TMP_TABLE) || have_rtree) ? 0 : 1;
411 if (share->concurrent_insert)
412 {
413 assert(0);
414 }
415 }
416 }
417 else
418 {
419 share= old_info->s;
420 if (mode == O_RDWR && share->mode == O_RDONLY)
421 {
422 errno=EACCES; /* Can't open in write mode */
423 goto err;
424 }
425 if (mi_open_datafile(&info, share, old_info->dfile))
426 goto err;
427 errpos=5;
428 have_rtree= old_info->rtree_recursion_state != NULL;
429 }
430
431 /* alloc and set up private structure parts */
432 if (!drizzled::memory::multi_malloc(MY_WME,
433 &m_info,sizeof(MI_INFO),
434 &info.blobs,sizeof(MI_BLOB)*share->base.blobs,
435 &info.buff,(share->base.max_key_block_length*2+
436 share->base.max_key_length),
437 &info.lastkey,share->base.max_key_length*3+1,
438 &info.first_mbr_key, share->base.max_key_length,
439 &info.filename, identifier.getPath().length()+1,
440 &info.rtree_recursion_state,have_rtree ? 1024 : 0,
441 NULL))
442 goto err;
443 errpos=6;
444
445 if (!have_rtree)
446 info.rtree_recursion_state= NULL;
447
448 strcpy(info.filename, identifier.getPath().c_str());
449 memcpy(info.blobs,share->blobs,sizeof(MI_BLOB)*share->base.blobs);
450 info.lastkey2=info.lastkey+share->base.max_key_length;
451
452 info.s=share;
453 info.lastpos= HA_OFFSET_ERROR;
454 info.update= (short) (HA_STATE_NEXT_FOUND+HA_STATE_PREV_FOUND);
455 info.opt_flag=READ_CHECK_USED;
456 info.this_unique= (ulong) info.dfile; /* Uniq number in process */
457 if (share->data_file_type == COMPRESSED_RECORD)
458 info.this_unique= share->state.unique;
459 info.this_loop=0; /* Update counter */
460 info.last_unique= share->state.unique;
461 info.last_loop= share->state.update_count;
462 if (mode == O_RDONLY)
463 share->options|=HA_OPTION_READ_ONLY_DATA;
464 info.lock_type=F_UNLCK;
465 info.quick_mode=0;
466 info.bulk_insert=0;
467 info.errkey= -1;
468 info.page_changed=1;
469 info.read_record=share->read_record;
470 share->reopen++;
471 share->write_flag=MYF(MY_NABP | MY_WAIT_IF_FULL);
472 if (share->options & HA_OPTION_READ_ONLY_DATA)
473 {
474 info.lock_type=F_RDLCK;
475 share->r_locks++;
476 share->tot_locks++;
477 }
478 if ((open_flags & HA_OPEN_TMP_TABLE) ||
479 (share->options & HA_OPTION_TMP_TABLE))
480 {
481 share->temporary=share->delay_key_write=1;
482 share->write_flag=MYF(MY_NABP);
483 /*
484 * The following two statements are commented out as a fix of
485 * bug https://bugs.launchpad.net/drizzle/+bug/387627
486 *
487 * UPDATE can be TRUNCATE on TEMPORARY TABLE (MyISAM).
488 * The root cause of why this makes a difference hasn't
489 * been found, but this fixes things for now.
490 */
491// share->w_locks++; // We don't have to update status
492// share->tot_locks++;
493 info.lock_type=F_WRLCK;
494 }
495
496 share->delay_key_write= 1;
497 info.state= &share->state.state; /* Change global values by default */
498
499 /* Allocate buffer for one record */
500
501 /* prerequisites: memset(info, 0) && info->s=share; are met. */
502 if (!mi_alloc_rec_buff(&info, SIZE_MAX, &info.rec_buff))
503 goto err;
504 memset(info.rec_buff, 0, mi_get_rec_buff_len(&info, info.rec_buff));
505
506 *m_info=info;
507 myisam_open_list.push_front(m_info);
508
509 THR_LOCK_myisam.unlock();
510 return(m_info);
511
512err:
513 free(disk_cache);
514 save_errno=errno ? errno : HA_ERR_END_OF_FILE;
515 if ((save_errno == HA_ERR_CRASHED) ||
516 (save_errno == HA_ERR_CRASHED_ON_USAGE) ||
517 (save_errno == HA_ERR_CRASHED_ON_REPAIR))
518 mi_report_error(save_errno, identifier.getPath().c_str());
519 switch (errpos) {
520 case 6:
521 free((unsigned char*) m_info);
522 /* fall through */
523 case 5:
524 internal::my_close(info.dfile,MYF(0));
525 if (old_info)
526 break; /* Don't remove open table */
527 /* fall through */
528 case 4:
529 free((unsigned char*) share);
530 /* fall through */
531 case 3:
532 /* fall through */
533 case 1:
534 internal::my_close(kfile,MYF(0));
535 /* fall through */
536 case 0:
537 default:
538 break;
539 }
540 THR_LOCK_myisam.unlock();
541 errno=save_errno;
542 return (NULL);
543} /* mi_open */
544
545
546unsigned char *mi_alloc_rec_buff(MI_INFO *info, size_t length, unsigned char **buf)
547{
548 uint32_t extra;
549 uint32_t old_length= 0;
550
551 if (! *buf || length > (old_length=mi_get_rec_buff_len(info, *buf)))
552 {
553 unsigned char *newptr = *buf;
554
555 /* to simplify initial init of info->rec_buf in mi_open and mi_extra */
556 if (length == SIZE_MAX)
557 {
558 if (info->s->options & HA_OPTION_COMPRESS_RECORD)
559 length= max(info->s->base.pack_reclength, info->s->max_pack_length);
560 else
561 length= info->s->base.pack_reclength;
562 length= max((uint32_t)length, info->s->base.max_key_length);
563 /* Avoid unnecessary realloc */
564 if (newptr && length == old_length)
565 return newptr;
566 }
567
568 extra= ((info->s->options & HA_OPTION_PACK_RECORD) ?
569 ALIGN_SIZE(MI_MAX_DYN_BLOCK_HEADER)+MI_SPLIT_LENGTH+
570 MI_REC_BUFF_OFFSET : 0);
571 if (extra && newptr)
572 newptr-= MI_REC_BUFF_OFFSET;
573 void *tmpnewptr= NULL;
574 if (!(tmpnewptr= realloc(newptr, length+extra+8)))
575 return newptr;
576 newptr= (unsigned char *)tmpnewptr;
577 *((uint32_t *) newptr)= (uint32_t) length;
578 *buf= newptr+(extra ? MI_REC_BUFF_OFFSET : 0);
579 }
580 return *buf;
581}
582
583
584static uint64_t mi_safe_mul(uint64_t a, uint64_t b)
585{
586 uint64_t max_val= ~ (uint64_t) 0; /* internal::my_off_t is unsigned */
587
588 if (!a || max_val / a < b)
589 return max_val;
590 return a*b;
591}
592
593 /* Set up functions in structs */
594
595void mi_setup_functions(MYISAM_SHARE *share)
596{
597 if (share->options & HA_OPTION_PACK_RECORD)
598 {
599 share->read_record=_mi_read_dynamic_record;
600 share->read_rnd=_mi_read_rnd_dynamic_record;
601 share->delete_record=_mi_delete_dynamic_record;
602 share->compare_record=_mi_cmp_dynamic_record;
603 share->compare_unique=_mi_cmp_dynamic_unique;
604 share->calc_checksum= mi_checksum;
605
606 /* add bits used to pack data to pack_reclength for faster allocation */
607 share->base.pack_reclength+= share->base.pack_bits;
608 if (share->base.blobs)
609 {
610 share->update_record=_mi_update_blob_record;
611 share->write_record=_mi_write_blob_record;
612 }
613 else
614 {
615 share->write_record=_mi_write_dynamic_record;
616 share->update_record=_mi_update_dynamic_record;
617 }
618 }
619 else
620 {
621 share->read_record=_mi_read_static_record;
622 share->read_rnd=_mi_read_rnd_static_record;
623 share->delete_record=_mi_delete_static_record;
624 share->compare_record=_mi_cmp_static_record;
625 share->update_record=_mi_update_static_record;
626 share->write_record=_mi_write_static_record;
627 share->compare_unique=_mi_cmp_static_unique;
628 share->calc_checksum= mi_static_checksum;
629 }
630 share->file_read= mi_nommap_pread;
631 share->file_write= mi_nommap_pwrite;
632 share->calc_checksum=0;
633}
634
635
636static void setup_key_functions(MI_KEYDEF *keyinfo)
637{
638 {
639 keyinfo->ck_insert = _mi_ck_write;
640 keyinfo->ck_delete = _mi_ck_delete;
641 }
642 if (keyinfo->flag & HA_BINARY_PACK_KEY)
643 { /* Simple prefix compression */
644 keyinfo->bin_search=_mi_seq_search;
645 keyinfo->get_key=_mi_get_binary_pack_key;
646 keyinfo->pack_key=_mi_calc_bin_pack_key_length;
647 keyinfo->store_key=_mi_store_bin_pack_key;
648 }
649 else if (keyinfo->flag & HA_VAR_LENGTH_KEY)
650 {
651 keyinfo->get_key= _mi_get_pack_key;
652 if (keyinfo->seg[0].flag & HA_PACK_KEY)
653 { /* Prefix compression */
654 /*
655 _mi_prefix_search() compares end-space against ASCII blank (' ').
656 It cannot be used for character sets, that do not encode the
657 blank character like ASCII does. UCS2 is an example. All
658 character sets with a fixed width > 1 or a mimimum width > 1
659 cannot represent blank like ASCII does. In these cases we have
660 to use _mi_seq_search() for the search.
661 */
662 if (not keyinfo->seg->charset || keyinfo->seg->charset->use_strnxfrm() ||
663 (keyinfo->seg->flag & HA_NULL_PART) ||
664 (keyinfo->seg->charset->mbminlen > 1))
665 keyinfo->bin_search=_mi_seq_search;
666 else
667 keyinfo->bin_search=_mi_prefix_search;
668 keyinfo->pack_key=_mi_calc_var_pack_key_length;
669 keyinfo->store_key=_mi_store_var_pack_key;
670 }
671 else
672 {
673 keyinfo->bin_search=_mi_seq_search;
674 keyinfo->pack_key=_mi_calc_var_key_length; /* Variable length key */
675 keyinfo->store_key=_mi_store_static_key;
676 }
677 }
678 else
679 {
680 keyinfo->bin_search=_mi_bin_search;
681 keyinfo->get_key=_mi_get_static_key;
682 keyinfo->pack_key=_mi_calc_static_key_length;
683 keyinfo->store_key=_mi_store_static_key;
684 }
685 return;
686}
687
688
689/*
690 Function to save and store the header in the index file (.MYI)
691*/
692
693uint32_t mi_state_info_write(int file, MI_STATE_INFO *state, uint32_t pWrite)
694{
695 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
696 unsigned char *ptr=buff;
697 uint i, keys= (uint) state->header.keys,
698 key_blocks=state->header.max_block_size_index;
699
700 memcpy(ptr,&state->header,sizeof(state->header));
701 ptr+=sizeof(state->header);
702
703 /* open_count must be first because of _mi_mark_file_changed ! */
704 mi_int2store(ptr,state->open_count); ptr +=2;
705 *ptr++= (unsigned char)state->changed; *ptr++= state->sortkey;
706 mi_rowstore(ptr,state->state.records); ptr +=8;
707 mi_rowstore(ptr,state->state.del); ptr +=8;
708 mi_rowstore(ptr,state->split); ptr +=8;
709 mi_sizestore(ptr,state->dellink); ptr +=8;
710 mi_sizestore(ptr,state->state.key_file_length); ptr +=8;
711 mi_sizestore(ptr,state->state.data_file_length); ptr +=8;
712 mi_sizestore(ptr,state->state.empty); ptr +=8;
713 mi_sizestore(ptr,state->state.key_empty); ptr +=8;
714 mi_int8store(ptr,state->auto_increment); ptr +=8;
715 mi_int8store(ptr,(uint64_t) state->state.checksum);ptr +=8;
716 mi_int4store(ptr,state->process); ptr +=4;
717 mi_int4store(ptr,state->unique); ptr +=4;
718 mi_int4store(ptr,state->status); ptr +=4;
719 mi_int4store(ptr,state->update_count); ptr +=4;
720
721 ptr+=state->state_diff_length;
722
723 for (i=0; i < keys; i++)
724 {
725 mi_sizestore(ptr,state->key_root[i]); ptr +=8;
726 }
727 for (i=0; i < key_blocks; i++)
728 {
729 mi_sizestore(ptr,state->key_del[i]); ptr +=8;
730 }
731 if (pWrite & 2) /* From isamchk */
732 {
733 uint32_t key_parts= mi_uint2korr(state->header.key_parts);
734 mi_int4store(ptr,state->sec_index_changed); ptr +=4;
735 mi_int4store(ptr,state->sec_index_used); ptr +=4;
736 mi_int4store(ptr,state->version); ptr +=4;
737 mi_int8store(ptr,state->key_map); ptr +=8;
738 mi_int8store(ptr,(uint64_t) state->create_time); ptr +=8;
739 mi_int8store(ptr,(uint64_t) state->recover_time); ptr +=8;
740 mi_int8store(ptr,(uint64_t) state->check_time); ptr +=8;
741 mi_sizestore(ptr,state->rec_per_key_rows); ptr+=8;
742 for (i=0 ; i < key_parts ; i++)
743 {
744 mi_int4store(ptr,state->rec_per_key_part[i]); ptr+=4;
745 }
746 }
747
748 if (pWrite & 1)
749 return(my_pwrite(file, buff, (size_t) (ptr-buff), 0L,
750 MYF(MY_NABP | MY_THREADSAFE)) != 0);
751 return(internal::my_write(file, buff, (size_t) (ptr-buff),
752 MYF(MY_NABP)) != 0);
753}
754
755
756static unsigned char *mi_state_info_read(unsigned char *ptr, MI_STATE_INFO *state)
757{
758 uint32_t i,keys,key_parts,key_blocks;
759 memcpy(&state->header,ptr, sizeof(state->header));
760 ptr +=sizeof(state->header);
761 keys=(uint) state->header.keys;
762 key_parts=mi_uint2korr(state->header.key_parts);
763 key_blocks=state->header.max_block_size_index;
764
765 state->open_count = mi_uint2korr(ptr); ptr +=2;
766 state->changed= *ptr++;
767 state->sortkey = (uint) *ptr++;
768 state->state.records= mi_rowkorr(ptr); ptr +=8;
769 state->state.del = mi_rowkorr(ptr); ptr +=8;
770 state->split = mi_rowkorr(ptr); ptr +=8;
771 state->dellink= mi_sizekorr(ptr); ptr +=8;
772 state->state.key_file_length = mi_sizekorr(ptr); ptr +=8;
773 state->state.data_file_length= mi_sizekorr(ptr); ptr +=8;
774 state->state.empty = mi_sizekorr(ptr); ptr +=8;
775 state->state.key_empty= mi_sizekorr(ptr); ptr +=8;
776 state->auto_increment=mi_uint8korr(ptr); ptr +=8;
777 state->state.checksum=(ha_checksum) mi_uint8korr(ptr); ptr +=8;
778 state->process= mi_uint4korr(ptr); ptr +=4;
779 state->unique = mi_uint4korr(ptr); ptr +=4;
780 state->status = mi_uint4korr(ptr); ptr +=4;
781 state->update_count=mi_uint4korr(ptr); ptr +=4;
782
783 ptr+= state->state_diff_length;
784
785 for (i=0; i < keys; i++)
786 {
787 state->key_root[i]= mi_sizekorr(ptr); ptr +=8;
788 }
789 for (i=0; i < key_blocks; i++)
790 {
791 state->key_del[i] = mi_sizekorr(ptr); ptr +=8;
792 }
793 state->sec_index_changed = mi_uint4korr(ptr); ptr +=4;
794 state->sec_index_used = mi_uint4korr(ptr); ptr +=4;
795 state->version = mi_uint4korr(ptr); ptr +=4;
796 state->key_map = mi_uint8korr(ptr); ptr +=8;
797 state->create_time = (time_t) mi_sizekorr(ptr); ptr +=8;
798 state->recover_time =(time_t) mi_sizekorr(ptr); ptr +=8;
799 state->check_time = (time_t) mi_sizekorr(ptr); ptr +=8;
800 state->rec_per_key_rows=mi_sizekorr(ptr); ptr +=8;
801 for (i=0 ; i < key_parts ; i++)
802 {
803 state->rec_per_key_part[i]= mi_uint4korr(ptr); ptr+=4;
804 }
805 return ptr;
806}
807
808
809uint32_t mi_state_info_read_dsk(int file, MI_STATE_INFO *state, bool pRead)
810{
811 unsigned char buff[MI_STATE_INFO_SIZE + MI_STATE_EXTRA_SIZE];
812
813 if (pRead)
814 {
815 if (my_pread(file, buff, state->state_length,0L, MYF(MY_NABP)))
816 return 1;
817 }
818 else if (internal::my_read(file, buff, state->state_length,MYF(MY_NABP)))
819 return 1;
820 mi_state_info_read(buff, state);
821
822 return 0;
823}
824
825
826/****************************************************************************
827** store and read of MI_BASE_INFO
828****************************************************************************/
829
830uint32_t mi_base_info_write(int file, MI_BASE_INFO *base)
831{
832 unsigned char buff[MI_BASE_INFO_SIZE], *ptr=buff;
833
834 mi_sizestore(ptr,base->keystart); ptr +=8;
835 mi_sizestore(ptr,base->max_data_file_length); ptr +=8;
836 mi_sizestore(ptr,base->max_key_file_length); ptr +=8;
837 mi_rowstore(ptr,base->records); ptr +=8;
838 mi_rowstore(ptr,base->reloc); ptr +=8;
839 mi_int4store(ptr,base->mean_row_length); ptr +=4;
840 mi_int4store(ptr,base->reclength); ptr +=4;
841 mi_int4store(ptr,base->pack_reclength); ptr +=4;
842 mi_int4store(ptr,base->min_pack_length); ptr +=4;
843 mi_int4store(ptr,base->max_pack_length); ptr +=4;
844 mi_int4store(ptr,base->min_block_length); ptr +=4;
845 mi_int4store(ptr,base->fields); ptr +=4;
846 mi_int4store(ptr,base->pack_fields); ptr +=4;
847 *ptr++=base->rec_reflength;
848 *ptr++=base->key_reflength;
849 *ptr++=base->keys;
850 *ptr++=base->auto_key;
851 mi_int2store(ptr,base->pack_bits); ptr +=2;
852 mi_int2store(ptr,base->blobs); ptr +=2;
853 mi_int2store(ptr,base->max_key_block_length); ptr +=2;
854 mi_int2store(ptr,base->max_key_length); ptr +=2;
855 mi_int2store(ptr,base->extra_alloc_bytes); ptr +=2;
856 *ptr++= base->extra_alloc_procent;
857 /* old raid info slots */
858 *ptr++= 0;
859 mi_int2store(ptr,UINT16_C(0)); ptr +=2;
860 mi_int4store(ptr,UINT32_C(0)); ptr +=4;
861
862 memset(ptr, 0, 6); ptr +=6; /* extra */
863 return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
864}
865
866
867static unsigned char *my_n_base_info_read(unsigned char *ptr, MI_BASE_INFO *base)
868{
869 base->keystart = mi_sizekorr(ptr); ptr +=8;
870 base->max_data_file_length = mi_sizekorr(ptr); ptr +=8;
871 base->max_key_file_length = mi_sizekorr(ptr); ptr +=8;
872 base->records = (ha_rows) mi_sizekorr(ptr); ptr +=8;
873 base->reloc = (ha_rows) mi_sizekorr(ptr); ptr +=8;
874 base->mean_row_length = mi_uint4korr(ptr); ptr +=4;
875 base->reclength = mi_uint4korr(ptr); ptr +=4;
876 base->pack_reclength = mi_uint4korr(ptr); ptr +=4;
877 base->min_pack_length = mi_uint4korr(ptr); ptr +=4;
878 base->max_pack_length = mi_uint4korr(ptr); ptr +=4;
879 base->min_block_length = mi_uint4korr(ptr); ptr +=4;
880 base->fields = mi_uint4korr(ptr); ptr +=4;
881 base->pack_fields = mi_uint4korr(ptr); ptr +=4;
882
883 base->rec_reflength = *ptr++;
884 base->key_reflength = *ptr++;
885 base->keys= *ptr++;
886 base->auto_key= *ptr++;
887 base->pack_bits = mi_uint2korr(ptr); ptr +=2;
888 base->blobs = mi_uint2korr(ptr); ptr +=2;
889 base->max_key_block_length= mi_uint2korr(ptr); ptr +=2;
890 base->max_key_length = mi_uint2korr(ptr); ptr +=2;
891 base->extra_alloc_bytes = mi_uint2korr(ptr); ptr +=2;
892 base->extra_alloc_procent = *ptr++;
893
894 /* advance past raid_type (1) raid_chunks (2) and raid_chunksize (4) */
895 ptr+= 7;
896
897 ptr+=6;
898 return ptr;
899}
900
901/*--------------------------------------------------------------------------
902 mi_keydef
903---------------------------------------------------------------------------*/
904
905uint32_t mi_keydef_write(int file, MI_KEYDEF *keydef)
906{
907 unsigned char buff[MI_KEYDEF_SIZE];
908 unsigned char *ptr=buff;
909
910 *ptr++ = (unsigned char) keydef->keysegs;
911 *ptr++ = keydef->key_alg; /* Rtree or Btree */
912 mi_int2store(ptr,keydef->flag); ptr +=2;
913 mi_int2store(ptr,keydef->block_length); ptr +=2;
914 mi_int2store(ptr,keydef->keylength); ptr +=2;
915 mi_int2store(ptr,keydef->minlength); ptr +=2;
916 mi_int2store(ptr,keydef->maxlength); ptr +=2;
917 return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
918}
919
920static unsigned char *mi_keydef_read(unsigned char *ptr, MI_KEYDEF *keydef)
921{
922 keydef->keysegs = (uint) *ptr++;
923 keydef->key_alg = *ptr++; /* Rtree or Btree */
924
925 keydef->flag = mi_uint2korr(ptr); ptr +=2;
926 keydef->block_length = mi_uint2korr(ptr); ptr +=2;
927 keydef->keylength = mi_uint2korr(ptr); ptr +=2;
928 keydef->minlength = mi_uint2korr(ptr); ptr +=2;
929 keydef->maxlength = mi_uint2korr(ptr); ptr +=2;
930 keydef->block_size_index= keydef->block_length/MI_MIN_KEY_BLOCK_LENGTH-1;
931 keydef->underflow_block_length=keydef->block_length/3;
932 keydef->version = 0; /* Not saved */
933 return ptr;
934}
935
936/***************************************************************************
937** mi_keyseg
938***************************************************************************/
939
940int mi_keyseg_write(int file, const HA_KEYSEG *keyseg)
941{
942 unsigned char buff[HA_KEYSEG_SIZE];
943 unsigned char *ptr=buff;
944 ulong pos;
945
946 *ptr++= keyseg->type;
947 *ptr++= keyseg->language;
948 *ptr++= keyseg->null_bit;
949 *ptr++= keyseg->bit_start;
950 *ptr++= keyseg->bit_end;
951 *ptr++= keyseg->bit_length;
952 mi_int2store(ptr,keyseg->flag); ptr+=2;
953 mi_int2store(ptr,keyseg->length); ptr+=2;
954 mi_int4store(ptr,keyseg->start); ptr+=4;
955 pos= keyseg->null_bit ? keyseg->null_pos : keyseg->bit_pos;
956 mi_int4store(ptr, pos);
957 ptr+=4;
958
959 return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
960}
961
962
963static unsigned char *mi_keyseg_read(unsigned char *ptr, HA_KEYSEG *keyseg)
964{
965 keyseg->type = *ptr++;
966 keyseg->language = *ptr++;
967 keyseg->null_bit = *ptr++;
968 keyseg->bit_start = *ptr++;
969 keyseg->bit_end = *ptr++;
970 keyseg->bit_length = *ptr++;
971 keyseg->flag = mi_uint2korr(ptr); ptr +=2;
972 keyseg->length = mi_uint2korr(ptr); ptr +=2;
973 keyseg->start = mi_uint4korr(ptr); ptr +=4;
974 keyseg->null_pos = mi_uint4korr(ptr); ptr +=4;
975 keyseg->charset=0; /* Will be filled in later */
976 if (keyseg->null_bit)
977 keyseg->bit_pos= (uint16_t)(keyseg->null_pos + (keyseg->null_bit == 7));
978 else
979 {
980 keyseg->bit_pos= (uint16_t)keyseg->null_pos;
981 keyseg->null_pos= 0;
982 }
983 return ptr;
984}
985
986/*--------------------------------------------------------------------------
987 mi_uniquedef
988---------------------------------------------------------------------------*/
989
990uint32_t mi_uniquedef_write(int file, MI_UNIQUEDEF *def)
991{
992 unsigned char buff[MI_UNIQUEDEF_SIZE];
993 unsigned char *ptr=buff;
994
995 mi_int2store(ptr,def->keysegs); ptr+=2;
996 *ptr++= (unsigned char) def->key;
997 *ptr++ = (unsigned char) def->null_are_equal;
998
999 return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1000}
1001
1002static unsigned char *mi_uniquedef_read(unsigned char *ptr, MI_UNIQUEDEF *def)
1003{
1004 def->keysegs = mi_uint2korr(ptr);
1005 def->key = ptr[2];
1006 def->null_are_equal=ptr[3];
1007 return ptr+4; /* 1 extra byte */
1008}
1009
1010/***************************************************************************
1011** MI_COLUMNDEF
1012***************************************************************************/
1013
1014uint32_t mi_recinfo_write(int file, MI_COLUMNDEF *recinfo)
1015{
1016 unsigned char buff[MI_COLUMNDEF_SIZE];
1017 unsigned char *ptr=buff;
1018
1019 mi_int2store(ptr,recinfo->type); ptr +=2;
1020 mi_int2store(ptr,recinfo->length); ptr +=2;
1021 *ptr++ = recinfo->null_bit;
1022 mi_int2store(ptr,recinfo->null_pos); ptr+= 2;
1023 return internal::my_write(file, buff, (size_t) (ptr-buff), MYF(MY_NABP)) != 0;
1024}
1025
1026static unsigned char *mi_recinfo_read(unsigned char *ptr, MI_COLUMNDEF *recinfo)
1027{
1028 recinfo->type= mi_sint2korr(ptr); ptr +=2;
1029 recinfo->length=mi_uint2korr(ptr); ptr +=2;
1030 recinfo->null_bit= (uint8_t) *ptr++;
1031 recinfo->null_pos=mi_uint2korr(ptr); ptr +=2;
1032 return ptr;
1033}
1034
1035/**************************************************************************
1036Open data file
1037We can't use dup() here as the data file descriptors need to have different
1038active seek-positions.
1039
1040The argument file_to_dup is here for the future if there would on some OS
1041exist a dup()-like call that would give us two different file descriptors.
1042*************************************************************************/
1043
1044int mi_open_datafile(MI_INFO *info, MYISAM_SHARE *share, int file_to_dup)
1045{
1046 (void)file_to_dup;
1047 info->dfile=internal::my_open(share->data_file_name, share->mode,
1048 MYF(MY_WME));
1049 return info->dfile >= 0 ? 0 : 1;
1050}
1051
1052
1053int mi_open_keyfile(MYISAM_SHARE *share)
1054{
1055 if ((share->kfile=internal::my_open(share->unique_file_name, share->mode,
1056 MYF(MY_WME))) < 0)
1057 return 1;
1058 return 0;
1059}
1060
1061
1062/*
1063 Disable all indexes.
1064
1065 SYNOPSIS
1066 mi_disable_indexes()
1067 info A pointer to the MyISAM storage engine MI_INFO struct.
1068
1069 DESCRIPTION
1070 Disable all indexes.
1071
1072 RETURN
1073 0 ok
1074*/
1075
1076int mi_disable_indexes(MI_INFO *info)
1077{
1078 MYISAM_SHARE *share= info->s;
1079
1080 mi_clear_all_keys_active(share->state.key_map);
1081 return 0;
1082}
1083
1084
1085/*
1086 Enable all indexes
1087
1088 SYNOPSIS
1089 mi_enable_indexes()
1090 info A pointer to the MyISAM storage engine MI_INFO struct.
1091
1092 DESCRIPTION
1093 Enable all indexes. The indexes might have been disabled
1094 by mi_disable_index() before.
1095 The function works only if both data and indexes are empty,
1096 otherwise a repair is required.
1097 To be sure, call handler::delete_all_rows() before.
1098
1099 RETURN
1100 0 ok
1101 HA_ERR_CRASHED data or index is non-empty.
1102*/
1103
1104int mi_enable_indexes(MI_INFO *info)
1105{
1106 int error= 0;
1107 MYISAM_SHARE *share= info->s;
1108
1109 if (share->state.state.data_file_length ||
1110 (share->state.state.key_file_length != share->base.keystart))
1111 {
1112 mi_print_error(info->s, HA_ERR_CRASHED);
1113 error= HA_ERR_CRASHED;
1114 }
1115 else
1116 mi_set_all_keys_active(share->state.key_map, share->base.keys);
1117 return error;
1118}
1119
1120
1121/*
1122 Test if indexes are disabled.
1123
1124 SYNOPSIS
1125 mi_indexes_are_disabled()
1126 info A pointer to the MyISAM storage engine MI_INFO struct.
1127
1128 DESCRIPTION
1129 Test if indexes are disabled.
1130
1131 RETURN
1132 0 indexes are not disabled
1133 1 all indexes are disabled
1134 2 non-unique indexes are disabled
1135*/
1136
1137int mi_indexes_are_disabled(MI_INFO *info)
1138{
1139 MYISAM_SHARE *share= info->s;
1140
1141 /*
1142 No keys or all are enabled. keys is the number of keys. Left shifted
1143 gives us only one bit set. When decreased by one, gives us all all bits
1144 up to this one set and it gets unset.
1145 */
1146 if (!share->base.keys ||
1147 (mi_is_all_keys_active(share->state.key_map, share->base.keys)))
1148 return 0;
1149
1150 /* All are disabled */
1151 if (mi_is_any_key_active(share->state.key_map))
1152 return 1;
1153
1154 /*
1155 We have keys. Some enabled, some disabled.
1156 Don't check for any non-unique disabled but return directly 2
1157 */
1158 return 2;
1159}
TODO: Rename this file - func.h is stupid.
STL namespace.